clang 12.0.1
SemaDecl.cpp
Go to the documentation of this file.
1//===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements semantic analysis for declarations.
10//
11//===----------------------------------------------------------------------===//
12
13#include "TypeLocBuilder.h"
16#include "clang/AST/ASTLambda.h"
18#include "clang/AST/CharUnits.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclObjC.h"
24#include "clang/AST/Expr.h"
25#include "clang/AST/ExprCXX.h"
27#include "clang/AST/StmtCXX.h"
32#include "clang/Lex/HeaderSearch.h" // TODO: Sema shouldn't depend on Lex
33#include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering.
34#include "clang/Lex/ModuleLoader.h" // TODO: Sema shouldn't depend on Lex
35#include "clang/Lex/Preprocessor.h" // Included for isCodeCompletionEnabled()
37#include "clang/Sema/DeclSpec.h"
40#include "clang/Sema/Lookup.h"
42#include "clang/Sema/Scope.h"
45#include "clang/Sema/Template.h"
46#include "llvm/ADT/SmallString.h"
47#include "llvm/ADT/Triple.h"
48#include <algorithm>
49#include <cstring>
50#include <functional>
51#include <unordered_map>
52
53using namespace clang;
54using namespace sema;
55
57 if (OwnedType) {
58 Decl *Group[2] = { OwnedType, Ptr };
60 }
61
63}
64
65namespace {
66
67class TypeNameValidatorCCC final : public CorrectionCandidateCallback {
68 public:
69 TypeNameValidatorCCC(bool AllowInvalid, bool WantClass = false,
70 bool AllowTemplates = false,
71 bool AllowNonTemplates = true)
72 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
73 AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
74 WantExpressionKeywords = false;
75 WantCXXNamedCasts = false;
76 WantRemainingKeywords = false;
77 }
78
79 bool ValidateCandidate(const TypoCorrection &candidate) override {
80 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
81 if (!AllowInvalidDecl && ND->isInvalidDecl())
82 return false;
83
85 return AllowTemplates;
86
87 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
88 if (!IsType)
89 return false;
90
91 if (AllowNonTemplates)
92 return true;
93
94 // An injected-class-name of a class template (specialization) is valid
95 // as a template or as a non-template.
96 if (AllowTemplates) {
97 auto *RD = dyn_cast<CXXRecordDecl>(ND);
98 if (!RD || !RD->isInjectedClassName())
99 return false;
100 RD = cast<CXXRecordDecl>(RD->getDeclContext());
101 return RD->getDescribedClassTemplate() ||
103 }
104
105 return false;
106 }
107
108 return !WantClassName && candidate.isKeyword();
109 }
110
111 std::unique_ptr<CorrectionCandidateCallback> clone() override {
112 return std::make_unique<TypeNameValidatorCCC>(*this);
113 }
114
115 private:
116 bool AllowInvalidDecl;
117 bool WantClassName;
118 bool AllowTemplates;
119 bool AllowNonTemplates;
120};
121
122} // end anonymous namespace
123
124/// Determine whether the token kind starts a simple-type-specifier.
126 switch (Kind) {
127 // FIXME: Take into account the current language when deciding whether a
128 // token kind is a valid type specifier
129 case tok::kw_short:
130 case tok::kw_long:
131 case tok::kw___int64:
132 case tok::kw___int128:
133 case tok::kw_signed:
134 case tok::kw_unsigned:
135 case tok::kw_void:
136 case tok::kw_char:
137 case tok::kw_int:
138 case tok::kw_half:
139 case tok::kw_float:
140 case tok::kw_double:
141 case tok::kw___bf16:
142 case tok::kw__Float16:
143 case tok::kw___float128:
144 case tok::kw_wchar_t:
145 case tok::kw_bool:
146 case tok::kw___underlying_type:
147 case tok::kw___auto_type:
148 return true;
149
150 case tok::annot_typename:
151 case tok::kw_char16_t:
152 case tok::kw_char32_t:
153 case tok::kw_typeof:
154 case tok::annot_decltype:
155 case tok::kw_decltype:
156 return getLangOpts().CPlusPlus;
157
158 case tok::kw_char8_t:
159 return getLangOpts().Char8;
160
161 default:
162 break;
163 }
164
165 return false;
166}
167
168namespace {
169enum class UnqualifiedTypeNameLookupResult {
170 NotFound,
171 FoundNonType,
172 FoundType
173};
174} // end anonymous namespace
175
176/// Tries to perform unqualified lookup of the type decls in bases for
177/// dependent class.
178/// \return \a NotFound if no any decls is found, \a FoundNotType if found not a
179/// type decl, \a FoundType if only type decls are found.
180static UnqualifiedTypeNameLookupResult
182 SourceLocation NameLoc,
183 const CXXRecordDecl *RD) {
184 if (!RD->hasDefinition())
185 return UnqualifiedTypeNameLookupResult::NotFound;
186 // Look for type decls in base classes.
187 UnqualifiedTypeNameLookupResult FoundTypeDecl =
188 UnqualifiedTypeNameLookupResult::NotFound;
189 for (const auto &Base : RD->bases()) {
190 const CXXRecordDecl *BaseRD = nullptr;
191 if (auto *BaseTT = Base.getType()->getAs<TagType>())
192 BaseRD = BaseTT->getAsCXXRecordDecl();
193 else if (auto *TST = Base.getType()->getAs<TemplateSpecializationType>()) {
194 // Look for type decls in dependent base classes that have known primary
195 // templates.
196 if (!TST || !TST->isDependentType())
197 continue;
198 auto *TD = TST->getTemplateName().getAsTemplateDecl();
199 if (!TD)
200 continue;
201 if (auto *BasePrimaryTemplate =
202 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
203 if (BasePrimaryTemplate->getCanonicalDecl() != RD->getCanonicalDecl())
204 BaseRD = BasePrimaryTemplate;
205 else if (auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
207 CTD->findPartialSpecialization(Base.getType()))
208 if (PS->getCanonicalDecl() != RD->getCanonicalDecl())
209 BaseRD = PS;
210 }
211 }
212 }
213 if (BaseRD) {
214 for (NamedDecl *ND : BaseRD->lookup(&II)) {
215 if (!isa<TypeDecl>(ND))
216 return UnqualifiedTypeNameLookupResult::FoundNonType;
217 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
218 }
219 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
220 switch (lookupUnqualifiedTypeNameInBase(S, II, NameLoc, BaseRD)) {
221 case UnqualifiedTypeNameLookupResult::FoundNonType:
222 return UnqualifiedTypeNameLookupResult::FoundNonType;
223 case UnqualifiedTypeNameLookupResult::FoundType:
224 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
225 break;
226 case UnqualifiedTypeNameLookupResult::NotFound:
227 break;
228 }
229 }
230 }
231 }
232
233 return FoundTypeDecl;
234}
235
237 const IdentifierInfo &II,
238 SourceLocation NameLoc) {
239 // Lookup in the parent class template context, if any.
240 const CXXRecordDecl *RD = nullptr;
241 UnqualifiedTypeNameLookupResult FoundTypeDecl =
242 UnqualifiedTypeNameLookupResult::NotFound;
243 for (DeclContext *DC = S.CurContext;
244 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
245 DC = DC->getParent()) {
246 // Look for type decls in dependent base classes that have known primary
247 // templates.
248 RD = dyn_cast<CXXRecordDecl>(DC);
249 if (RD && RD->getDescribedClassTemplate())
250 FoundTypeDecl = lookupUnqualifiedTypeNameInBase(S, II, NameLoc, RD);
251 }
252 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
253 return nullptr;
254
255 // We found some types in dependent base classes. Recover as if the user
256 // wrote 'typename MyClass::II' instead of 'II'. We'll fully resolve the
257 // lookup during template instantiation.
258 S.Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
259
260 ASTContext &Context = S.Context;
261 auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false,
262 cast<Type>(Context.getRecordType(RD)));
263 QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II);
264
265 CXXScopeSpec SS;
266 SS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
267
268 TypeLocBuilder Builder;
269 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
270 DepTL.setNameLoc(NameLoc);
272 DepTL.setQualifierLoc(SS.getWithLocInContext(Context));
273 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
274}
275
276/// If the identifier refers to a type name within this scope,
277/// return the declaration of that type.
278///
279/// This routine performs ordinary name lookup of the identifier II
280/// within the given scope, with optional C++ scope specifier SS, to
281/// determine whether the name refers to a type. If so, returns an
282/// opaque pointer (actually a QualType) corresponding to that
283/// type. Otherwise, returns NULL.
285 Scope *S, CXXScopeSpec *SS,
286 bool isClassName, bool HasTrailingDot,
287 ParsedType ObjectTypePtr,
288 bool IsCtorOrDtorName,
289 bool WantNontrivialTypeSourceInfo,
290 bool IsClassTemplateDeductionContext,
291 IdentifierInfo **CorrectedII) {
292 // FIXME: Consider allowing this outside C++1z mode as an extension.
293 bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
294 getLangOpts().CPlusPlus17 && !IsCtorOrDtorName &&
295 !isClassName && !HasTrailingDot;
296
297 // Determine where we will perform name lookup.
298 DeclContext *LookupCtx = nullptr;
299 if (ObjectTypePtr) {
300 QualType ObjectType = ObjectTypePtr.get();
301 if (ObjectType->isRecordType())
302 LookupCtx = computeDeclContext(ObjectType);
303 } else if (SS && SS->isNotEmpty()) {
304 LookupCtx = computeDeclContext(*SS, false);
305
306 if (!LookupCtx) {
307 if (isDependentScopeSpecifier(*SS)) {
308 // C++ [temp.res]p3:
309 // A qualified-id that refers to a type and in which the
310 // nested-name-specifier depends on a template-parameter (14.6.2)
311 // shall be prefixed by the keyword typename to indicate that the
312 // qualified-id denotes a type, forming an
313 // elaborated-type-specifier (7.1.5.3).
314 //
315 // We therefore do not perform any name lookup if the result would
316 // refer to a member of an unknown specialization.
317 if (!isClassName && !IsCtorOrDtorName)
318 return nullptr;
319
320 // We know from the grammar that this name refers to a type,
321 // so build a dependent node to describe the type.
322 if (WantNontrivialTypeSourceInfo)
323 return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
324
327 II, NameLoc);
328 return ParsedType::make(T);
329 }
330
331 return nullptr;
332 }
333
334 if (!LookupCtx->isDependentContext() &&
335 RequireCompleteDeclContext(*SS, LookupCtx))
336 return nullptr;
337 }
338
339 // FIXME: LookupNestedNameSpecifierName isn't the right kind of
340 // lookup for class-names.
341 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
343 LookupResult Result(*this, &II, NameLoc, Kind);
344 if (LookupCtx) {
345 // Perform "qualified" name lookup into the declaration context we
346 // computed, which is either the type of the base of a member access
347 // expression or the declaration context associated with a prior
348 // nested-name-specifier.
349 LookupQualifiedName(Result, LookupCtx);
350
351 if (ObjectTypePtr && Result.empty()) {
352 // C++ [basic.lookup.classref]p3:
353 // If the unqualified-id is ~type-name, the type-name is looked up
354 // in the context of the entire postfix-expression. If the type T of
355 // the object expression is of a class type C, the type-name is also
356 // looked up in the scope of class C. At least one of the lookups shall
357 // find a name that refers to (possibly cv-qualified) T.
358 LookupName(Result, S);
359 }
360 } else {
361 // Perform unqualified name lookup.
362 LookupName(Result, S);
363
364 // For unqualified lookup in a class template in MSVC mode, look into
365 // dependent base classes where the primary class template is known.
366 if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) {
367 if (ParsedType TypeInBase =
368 recoverFromTypeInKnownDependentBase(*this, II, NameLoc))
369 return TypeInBase;
370 }
371 }
372
373 NamedDecl *IIDecl = nullptr;
374 switch (Result.getResultKind()) {
377 if (CorrectedII) {
378 TypeNameValidatorCCC CCC(/*AllowInvalid=*/true, isClassName,
379 AllowDeducedTemplate);
380 TypoCorrection Correction = CorrectTypo(Result.getLookupNameInfo(), Kind,
381 S, SS, CCC, CTK_ErrorRecovery);
382 IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo();
383 TemplateTy Template;
384 bool MemberOfUnknownSpecialization;
386 TemplateName.setIdentifier(NewII, NameLoc);
388 CXXScopeSpec NewSS, *NewSSPtr = SS;
389 if (SS && NNS) {
390 NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
391 NewSSPtr = &NewSS;
392 }
393 if (Correction && (NNS || NewII != &II) &&
394 // Ignore a correction to a template type as the to-be-corrected
395 // identifier is not a template (typo correction for template names
396 // is handled elsewhere).
397 !(getLangOpts().CPlusPlus && NewSSPtr &&
398 isTemplateName(S, *NewSSPtr, false, TemplateName, nullptr, false,
399 Template, MemberOfUnknownSpecialization))) {
400 ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr,
401 isClassName, HasTrailingDot, ObjectTypePtr,
402 IsCtorOrDtorName,
403 WantNontrivialTypeSourceInfo,
404 IsClassTemplateDeductionContext);
405 if (Ty) {
406 diagnoseTypo(Correction,
407 PDiag(diag::err_unknown_type_or_class_name_suggest)
408 << Result.getLookupName() << isClassName);
409 if (SS && NNS)
410 SS->MakeTrivial(Context, NNS, SourceRange(NameLoc));
411 *CorrectedII = NewII;
412 return Ty;
413 }
414 }
415 }
416 // If typo correction failed or was not performed, fall through
417 LLVM_FALLTHROUGH;
420 Result.suppressDiagnostics();
421 return nullptr;
422
424 // Recover from type-hiding ambiguities by hiding the type. We'll
425 // do the lookup again when looking for an object, and we can
426 // diagnose the error then. If we don't do this, then the error
427 // about hiding the type will be immediately followed by an error
428 // that only makes sense if the identifier was treated like a type.
429 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
430 Result.suppressDiagnostics();
431 return nullptr;
432 }
433
434 // Look to see if we have a type anywhere in the list of results.
435 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
436 Res != ResEnd; ++Res) {
437 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res) ||
438 (AllowDeducedTemplate && getAsTypeTemplateDecl(*Res))) {
439 if (!IIDecl || (*Res)->getLocation() < IIDecl->getLocation())
440 IIDecl = *Res;
441 }
442 }
443
444 if (!IIDecl) {
445 // None of the entities we found is a type, so there is no way
446 // to even assume that the result is a type. In this case, don't
447 // complain about the ambiguity. The parser will either try to
448 // perform this lookup again (e.g., as an object name), which
449 // will produce the ambiguity, or will complain that it expected
450 // a type name.
451 Result.suppressDiagnostics();
452 return nullptr;
453 }
454
455 // We found a type within the ambiguous lookup; diagnose the
456 // ambiguity and then return that type. This might be the right
457 // answer, or it might not be, but it suppresses any attempt to
458 // perform the name lookup again.
459 break;
460
462 IIDecl = Result.getFoundDecl();
463 break;
464 }
465
466 assert(IIDecl && "Didn't find decl");
467
468 QualType T;
469 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
470 // C++ [class.qual]p2: A lookup that would find the injected-class-name
471 // instead names the constructors of the class, except when naming a class.
472 // This is ill-formed when we're not actually forming a ctor or dtor name.
473 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
474 auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
475 if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
476 FoundRD->isInjectedClassName() &&
477 declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
478 Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
479 << &II << /*Type*/1;
480
481 DiagnoseUseOfDecl(IIDecl, NameLoc);
482
483 T = Context.getTypeDeclType(TD);
484 MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
485 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
486 (void)DiagnoseUseOfDecl(IDecl, NameLoc);
487 if (!HasTrailingDot)
488 T = Context.getObjCInterfaceType(IDecl);
489 } else if (AllowDeducedTemplate) {
490 if (auto *TD = getAsTypeTemplateDecl(IIDecl))
492 QualType(), false);
493 }
494
495 if (T.isNull()) {
496 // If it's not plausibly a type, suppress diagnostics.
497 Result.suppressDiagnostics();
498 return nullptr;
499 }
500
501 // NOTE: avoid constructing an ElaboratedType(Loc) if this is a
502 // constructor or destructor name (in such a case, the scope specifier
503 // will be attached to the enclosing Expr or Decl node).
504 if (SS && SS->isNotEmpty() && !IsCtorOrDtorName &&
505 !isa<ObjCInterfaceDecl>(IIDecl)) {
506 if (WantNontrivialTypeSourceInfo) {
507 // Construct a type with type-source information.
508 TypeLocBuilder Builder;
509 Builder.pushTypeSpec(T).setNameLoc(NameLoc);
510
511 T = getElaboratedType(ETK_None, *SS, T);
512 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
515 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
516 } else {
517 T = getElaboratedType(ETK_None, *SS, T);
518 }
519 }
520
521 return ParsedType::make(T);
522}
523
524// Builds a fake NNS for the given decl context.
525static NestedNameSpecifier *
527 for (;; DC = DC->getLookupParent()) {
528 DC = DC->getPrimaryContext();
529 auto *ND = dyn_cast<NamespaceDecl>(DC);
530 if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
531 return NestedNameSpecifier::Create(Context, nullptr, ND);
532 else if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
533 return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
534 RD->getTypeForDecl());
535 else if (isa<TranslationUnitDecl>(DC))
537 }
538 llvm_unreachable("something isn't in TU scope?");
539}
540
541/// Find the parent class with dependent bases of the innermost enclosing method
542/// context. Do not look for enclosing CXXRecordDecls directly, or we will end
543/// up allowing unqualified dependent type names at class-level, which MSVC
544/// correctly rejects.
545static const CXXRecordDecl *
547 for (; DC && DC->isDependentContext(); DC = DC->getLookupParent()) {
548 DC = DC->getPrimaryContext();
549 if (const auto *MD = dyn_cast<CXXMethodDecl>(DC))
550 if (MD->getParent()->hasAnyDependentBases())
551 return MD->getParent();
552 }
553 return nullptr;
554}
555
557 SourceLocation NameLoc,
558 bool IsTemplateTypeArg) {
559 assert(getLangOpts().MSVCCompat && "shouldn't be called in non-MSVC mode");
560
561 NestedNameSpecifier *NNS = nullptr;
562 if (IsTemplateTypeArg && getCurScope()->isTemplateParamScope()) {
563 // If we weren't able to parse a default template argument, delay lookup
564 // until instantiation time by making a non-dependent DependentTypeName. We
565 // pretend we saw a NestedNameSpecifier referring to the current scope, and
566 // lookup is retried.
567 // FIXME: This hurts our diagnostic quality, since we get errors like "no
568 // type named 'Foo' in 'current_namespace'" when the user didn't write any
569 // name specifiers.
571 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
572 } else if (const CXXRecordDecl *RD =
574 // Build a DependentNameType that will perform lookup into RD at
575 // instantiation time.
576 NNS = NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
577 RD->getTypeForDecl());
578
579 // Diagnose that this identifier was undeclared, and retry the lookup during
580 // template instantiation.
581 Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
582 << RD;
583 } else {
584 // This is not a situation that we should recover from.
585 return ParsedType();
586 }
587
589
590 // Build type location information. We synthesized the qualifier, so we have
591 // to build a fake NestedNameSpecifierLoc.
592 NestedNameSpecifierLocBuilder NNSLocBuilder;
593 NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc));
594 NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context);
595
596 TypeLocBuilder Builder;
597 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
598 DepTL.setNameLoc(NameLoc);
600 DepTL.setQualifierLoc(QualifierLoc);
601 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
602}
603
604/// isTagName() - This method is called *for error recovery purposes only*
605/// to determine if the specified name is a valid tag name ("struct foo"). If
606/// so, this returns the TST for the tag corresponding to it (TST_enum,
607/// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose
608/// cases in C where the user forgot to specify the tag.
610 // Do a tag name lookup in this scope.
611 LookupResult R(*this, &II, SourceLocation(), LookupTagName);
612 LookupName(R, S, false);
615 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
616 switch (TD->getTagKind()) {
617 case TTK_Struct: return DeclSpec::TST_struct;
619 case TTK_Union: return DeclSpec::TST_union;
620 case TTK_Class: return DeclSpec::TST_class;
621 case TTK_Enum: return DeclSpec::TST_enum;
622 }
623 }
624
626}
627
628/// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
629/// if a CXXScopeSpec's type is equal to the type of one of the base classes
630/// then downgrade the missing typename error to a warning.
631/// This is needed for MSVC compatibility; Example:
632/// @code
633/// template<class T> class A {
634/// public:
635/// typedef int TYPE;
636/// };
637/// template<class T> class B : public A<T> {
638/// public:
639/// A<T>::TYPE a; // no typename required because A<T> is a base class.
640/// };
641/// @endcode
643 if (CurContext->isRecord()) {
645 return true;
646
647 const Type *Ty = SS->getScopeRep()->getAsType();
648
650 for (const auto &Base : RD->bases())
651 if (Ty && Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType()))
652 return true;
653 return S->isFunctionPrototypeScope();
654 }
655 return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope();
656}
657
659 SourceLocation IILoc,
660 Scope *S,
661 CXXScopeSpec *SS,
662 ParsedType &SuggestedType,
663 bool IsTemplateName) {
664 // Don't report typename errors for editor placeholders.
665 if (II->isEditorPlaceholder())
666 return;
667 // We don't have anything to suggest (yet).
668 SuggestedType = nullptr;
669
670 // There may have been a typo in the name of the type. Look up typo
671 // results, in case we have something that we can suggest.
672 TypeNameValidatorCCC CCC(/*AllowInvalid=*/false, /*WantClass=*/false,
673 /*AllowTemplates=*/IsTemplateName,
674 /*AllowNonTemplates=*/!IsTemplateName);
675 if (TypoCorrection Corrected =
677 CCC, CTK_ErrorRecovery)) {
678 // FIXME: Support error recovery for the template-name case.
679 bool CanRecover = !IsTemplateName;
680 if (Corrected.isKeyword()) {
681 // We corrected to a keyword.
682 diagnoseTypo(Corrected,
683 PDiag(IsTemplateName ? diag::err_no_template_suggest
684 : diag::err_unknown_typename_suggest)
685 << II);
686 II = Corrected.getCorrectionAsIdentifierInfo();
687 } else {
688 // We found a similarly-named type or interface; suggest that.
689 if (!SS || !SS->isSet()) {
690 diagnoseTypo(Corrected,
691 PDiag(IsTemplateName ? diag::err_no_template_suggest
692 : diag::err_unknown_typename_suggest)
693 << II, CanRecover);
694 } else if (DeclContext *DC = computeDeclContext(*SS, false)) {
695 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
696 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
697 II->getName().equals(CorrectedStr);
698 diagnoseTypo(Corrected,
699 PDiag(IsTemplateName
700 ? diag::err_no_member_template_suggest
701 : diag::err_unknown_nested_typename_suggest)
702 << II << DC << DroppedSpecifier << SS->getRange(),
703 CanRecover);
704 } else {
705 llvm_unreachable("could not have corrected a typo here");
706 }
707
708 if (!CanRecover)
709 return;
710
711 CXXScopeSpec tmpSS;
712 if (Corrected.getCorrectionSpecifier())
713 tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
714 SourceRange(IILoc));
715 // FIXME: Support class template argument deduction here.
716 SuggestedType =
717 getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
718 tmpSS.isSet() ? &tmpSS : SS, false, false, nullptr,
719 /*IsCtorOrDtorName=*/false,
720 /*WantNontrivialTypeSourceInfo=*/true);
721 }
722 return;
723 }
724
725 if (getLangOpts().CPlusPlus && !IsTemplateName) {
726 // See if II is a class template that the user forgot to pass arguments to.
727 UnqualifiedId Name;
728 Name.setIdentifier(II, IILoc);
729 CXXScopeSpec EmptySS;
730 TemplateTy TemplateResult;
731 bool MemberOfUnknownSpecialization;
732 if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false,
733 Name, nullptr, true, TemplateResult,
734 MemberOfUnknownSpecialization) == TNK_Type_template) {
735 diagnoseMissingTemplateArguments(TemplateResult.get(), IILoc);
736 return;
737 }
738 }
739
740 // FIXME: Should we move the logic that tries to recover from a missing tag
741 // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
742
743 if (!SS || (!SS->isSet() && !SS->isInvalid()))
744 Diag(IILoc, IsTemplateName ? diag::err_no_template
745 : diag::err_unknown_typename)
746 << II;
747 else if (DeclContext *DC = computeDeclContext(*SS, false))
748 Diag(IILoc, IsTemplateName ? diag::err_no_member_template
749 : diag::err_typename_nested_not_found)
750 << II << DC << SS->getRange();
751 else if (SS->isValid() && SS->getScopeRep()->containsErrors()) {
752 SuggestedType =
753 ActOnTypenameType(S, SourceLocation(), *SS, *II, IILoc).get();
754 } else if (isDependentScopeSpecifier(*SS)) {
755 unsigned DiagID = diag::err_typename_missing;
756 if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S))
757 DiagID = diag::ext_typename_missing;
758
759 Diag(SS->getRange().getBegin(), DiagID)
760 << SS->getScopeRep() << II->getName()
761 << SourceRange(SS->getRange().getBegin(), IILoc)
762 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
763 SuggestedType = ActOnTypenameType(S, SourceLocation(),
764 *SS, *II, IILoc).get();
765 } else {
766 assert(SS && SS->isInvalid() &&
767 "Invalid scope specifier has already been diagnosed");
768 }
769}
770
771/// Determine whether the given result set contains either a type name
772/// or
773static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
774 bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus &&
775 NextToken.is(tok::less);
776
777 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
778 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
779 return true;
780
781 if (CheckTemplate && isa<TemplateDecl>(*I))
782 return true;
783 }
784
785 return false;
786}
787
789 Scope *S, CXXScopeSpec &SS,
790 IdentifierInfo *&Name,
791 SourceLocation NameLoc) {
792 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
793 SemaRef.LookupParsedName(R, S, &SS);
794 if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
795 StringRef FixItTagName;
796 switch (Tag->getTagKind()) {
797 case TTK_Class:
798 FixItTagName = "class ";
799 break;
800
801 case TTK_Enum:
802 FixItTagName = "enum ";
803 break;
804
805 case TTK_Struct:
806 FixItTagName = "struct ";
807 break;
808
809 case TTK_Interface:
810 FixItTagName = "__interface ";
811 break;
812
813 case TTK_Union:
814 FixItTagName = "union ";
815 break;
816 }
817
818 StringRef TagName = FixItTagName.drop_back();
819 SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
820 << Name << TagName << SemaRef.getLangOpts().CPlusPlus
821 << FixItHint::CreateInsertion(NameLoc, FixItTagName);
822
823 for (LookupResult::iterator I = Result.begin(), IEnd = Result.end();
824 I != IEnd; ++I)
825 SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
826 << Name << TagName;
827
828 // Replace lookup results with just the tag decl.
830 SemaRef.LookupParsedName(Result, S, &SS);
831 return true;
832 }
833
834 return false;
835}
836
837/// Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
839 QualType T, SourceLocation NameLoc) {
840 ASTContext &Context = S.Context;
841
842 TypeLocBuilder Builder;
843 Builder.pushTypeSpec(T).setNameLoc(NameLoc);
844
845 T = S.getElaboratedType(ETK_None, SS, T);
846 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
848 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
849 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
850}
851
853 IdentifierInfo *&Name,
854 SourceLocation NameLoc,
855 const Token &NextToken,
857 DeclarationNameInfo NameInfo(Name, NameLoc);
858 ObjCMethodDecl *CurMethod = getCurMethodDecl();
859
860 assert(NextToken.isNot(tok::coloncolon) &&
861 "parse nested name specifiers before calling ClassifyName");
862 if (getLangOpts().CPlusPlus && SS.isSet() &&
863 isCurrentClassName(*Name, S, &SS)) {
864 // Per [class.qual]p2, this names the constructors of SS, not the
865 // injected-class-name. We don't have a classification for that.
866 // There's not much point caching this result, since the parser
867 // will reject it later.
869 }
870
871 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
872 LookupParsedName(Result, S, &SS, !CurMethod);
873
874 if (SS.isInvalid())
876
877 // For unqualified lookup in a class template in MSVC mode, look into
878 // dependent base classes where the primary class template is known.
879 if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
880 if (ParsedType TypeInBase =
881 recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc))
882 return TypeInBase;
883 }
884
885 // Perform lookup for Objective-C instance variables (including automatically
886 // synthesized instance variables), if we're in an Objective-C method.
887 // FIXME: This lookup really, really needs to be folded in to the normal
888 // unqualified lookup mechanism.
889 if (SS.isEmpty() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
891 if (Ivar.isInvalid())
893 if (Ivar.isUsable())
894 return NameClassification::NonType(cast<NamedDecl>(Ivar.get()));
895
896 // We defer builtin creation until after ivar lookup inside ObjC methods.
897 if (Result.empty())
899 }
900
901 bool SecondTry = false;
902 bool IsFilteredTemplateName = false;
903
904Corrected:
905 switch (Result.getResultKind()) {
907 // If an unqualified-id is followed by a '(', then we have a function
908 // call.
909 if (SS.isEmpty() && NextToken.is(tok::l_paren)) {
910 // In C++, this is an ADL-only call.
911 // FIXME: Reference?
914
915 // C90 6.3.2.2:
916 // If the expression that precedes the parenthesized argument list in a
917 // function call consists solely of an identifier, and if no
918 // declaration is visible for this identifier, the identifier is
919 // implicitly declared exactly as if, in the innermost block containing
920 // the function call, the declaration
921 //
922 // extern int identifier ();
923 //
924 // appeared.
925 //
926 // We also allow this in C99 as an extension.
927 if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S))
929 }
930
931 if (getLangOpts().CPlusPlus20 && SS.isEmpty() && NextToken.is(tok::less)) {
932 // In C++20 onwards, this could be an ADL-only call to a function
933 // template, and we're required to assume that this is a template name.
934 //
935 // FIXME: Find a way to still do typo correction in this case.
936 TemplateName Template =
939 }
940
941 // In C, we first see whether there is a tag type by the same name, in
942 // which case it's likely that the user just forgot to write "enum",
943 // "struct", or "union".
944 if (!getLangOpts().CPlusPlus && !SecondTry &&
945 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
946 break;
947 }
948
949 // Perform typo correction to determine if there is another name that is
950 // close to this name.
951 if (!SecondTry && CCC) {
952 SecondTry = true;
953 if (TypoCorrection Corrected =
954 CorrectTypo(Result.getLookupNameInfo(), Result.getLookupKind(), S,
955 &SS, *CCC, CTK_ErrorRecovery)) {
956 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
957 unsigned QualifiedDiag = diag::err_no_member_suggest;
958
959 NamedDecl *FirstDecl = Corrected.getFoundDecl();
960 NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
961 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
962 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
963 UnqualifiedDiag = diag::err_no_template_suggest;
964 QualifiedDiag = diag::err_no_member_template_suggest;
965 } else if (UnderlyingFirstDecl &&
966 (isa<TypeDecl>(UnderlyingFirstDecl) ||
967 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
968 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
969 UnqualifiedDiag = diag::err_unknown_typename_suggest;
970 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
971 }
972
973 if (SS.isEmpty()) {
974 diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name);
975 } else {// FIXME: is this even reachable? Test it.
976 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
977 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
978 Name->getName().equals(CorrectedStr);
979 diagnoseTypo(Corrected, PDiag(QualifiedDiag)
980 << Name << computeDeclContext(SS, false)
981 << DroppedSpecifier << SS.getRange());
982 }
983
984 // Update the name, so that the caller has the new name.
985 Name = Corrected.getCorrectionAsIdentifierInfo();
986
987 // Typo correction corrected to a keyword.
988 if (Corrected.isKeyword())
989 return Name;
990
991 // Also update the LookupResult...
992 // FIXME: This should probably go away at some point
993 Result.clear();
994 Result.setLookupName(Corrected.getCorrection());
995 if (FirstDecl)
996 Result.addDecl(FirstDecl);
997
998 // If we found an Objective-C instance variable, let
999 // LookupInObjCMethod build the appropriate expression to
1000 // reference the ivar.
1001 // FIXME: This is a gross hack.
1002 if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
1003 DeclResult R =
1004 LookupIvarInObjCMethod(Result, S, Ivar->getIdentifier());
1005 if (R.isInvalid())
1007 if (R.isUsable())
1008 return NameClassification::NonType(Ivar);
1009 }
1010
1011 goto Corrected;
1012 }
1013 }
1014
1015 // We failed to correct; just fall through and let the parser deal with it.
1016 Result.suppressDiagnostics();
1018
1020 // We performed name lookup into the current instantiation, and there were
1021 // dependent bases, so we treat this result the same way as any other
1022 // dependent nested-name-specifier.
1023
1024 // C++ [temp.res]p2:
1025 // A name used in a template declaration or definition and that is
1026 // dependent on a template-parameter is assumed not to name a type
1027 // unless the applicable name lookup finds a type name or the name is
1028 // qualified by the keyword typename.
1029 //
1030 // FIXME: If the next token is '<', we might want to ask the parser to
1031 // perform some heroics to see if we actually have a
1032 // template-argument-list, which would indicate a missing 'template'
1033 // keyword here.
1035 }
1036
1040 break;
1041
1043 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
1044 hasAnyAcceptableTemplateNames(Result, /*AllowFunctionTemplates=*/true,
1045 /*AllowDependent=*/false)) {
1046 // C++ [temp.local]p3:
1047 // A lookup that finds an injected-class-name (10.2) can result in an
1048 // ambiguity in certain cases (for example, if it is found in more than
1049 // one base class). If all of the injected-class-names that are found
1050 // refer to specializations of the same class template, and if the name
1051 // is followed by a template-argument-list, the reference refers to the
1052 // class template itself and not a specialization thereof, and is not
1053 // ambiguous.
1054 //
1055 // This filtering can make an ambiguous result into an unambiguous one,
1056 // so try again after filtering out template names.
1058 if (!Result.isAmbiguous()) {
1059 IsFilteredTemplateName = true;
1060 break;
1061 }
1062 }
1063
1064 // Diagnose the ambiguity and return an error.
1066 }
1067
1068 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
1069 (IsFilteredTemplateName ||
1071 Result, /*AllowFunctionTemplates=*/true,
1072 /*AllowDependent=*/false,
1073 /*AllowNonTemplateFunctions*/ SS.isEmpty() &&
1075 // C++ [temp.names]p3:
1076 // After name lookup (3.4) finds that a name is a template-name or that
1077 // an operator-function-id or a literal- operator-id refers to a set of
1078 // overloaded functions any member of which is a function template if
1079 // this is followed by a <, the < is always taken as the delimiter of a
1080 // template-argument-list and never as the less-than operator.
1081 // C++2a [temp.names]p2:
1082 // A name is also considered to refer to a template if it is an
1083 // unqualified-id followed by a < and name lookup finds either one
1084 // or more functions or finds nothing.
1085 if (!IsFilteredTemplateName)
1087
1088 bool IsFunctionTemplate;
1089 bool IsVarTemplate;
1090 TemplateName Template;
1091 if (Result.end() - Result.begin() > 1) {
1092 IsFunctionTemplate = true;
1093 Template = Context.getOverloadedTemplateName(Result.begin(),
1094 Result.end());
1095 } else if (!Result.empty()) {
1097 *Result.begin(), /*AllowFunctionTemplates=*/true,
1098 /*AllowDependent=*/false));
1099 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
1100 IsVarTemplate = isa<VarTemplateDecl>(TD);
1101
1102 if (SS.isNotEmpty())
1103 Template =
1105 /*TemplateKeyword=*/false, TD);
1106 else
1107 Template = TemplateName(TD);
1108 } else {
1109 // All results were non-template functions. This is a function template
1110 // name.
1111 IsFunctionTemplate = true;
1112 Template = Context.getAssumedTemplateName(NameInfo.getName());
1113 }
1114
1115 if (IsFunctionTemplate) {
1116 // Function templates always go through overload resolution, at which
1117 // point we'll perform the various checks (e.g., accessibility) we need
1118 // to based on which function we selected.
1119 Result.suppressDiagnostics();
1120
1121 return NameClassification::FunctionTemplate(Template);
1122 }
1123
1124 return IsVarTemplate ? NameClassification::VarTemplate(Template)
1126 }
1127
1128 NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
1129 if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
1130 DiagnoseUseOfDecl(Type, NameLoc);
1131 MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
1133 if (SS.isNotEmpty())
1134 return buildNestedType(*this, SS, T, NameLoc);
1135 return ParsedType::make(T);
1136 }
1137
1138 ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
1139 if (!Class) {
1140 // FIXME: It's unfortunate that we don't have a Type node for handling this.
1141 if (ObjCCompatibleAliasDecl *Alias =
1142 dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
1143 Class = Alias->getClassInterface();
1144 }
1145
1146 if (Class) {
1147 DiagnoseUseOfDecl(Class, NameLoc);
1148
1149 if (NextToken.is(tok::period)) {
1150 // Interface. <something> is parsed as a property reference expression.
1151 // Just return "unknown" as a fall-through for now.
1152 Result.suppressDiagnostics();
1154 }
1155
1157 return ParsedType::make(T);
1158 }
1159
1160 if (isa<ConceptDecl>(FirstDecl))
1162 TemplateName(cast<TemplateDecl>(FirstDecl)));
1163
1164 // We can have a type template here if we're classifying a template argument.
1165 if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl) &&
1166 !isa<VarTemplateDecl>(FirstDecl))
1168 TemplateName(cast<TemplateDecl>(FirstDecl)));
1169
1170 // Check for a tag type hidden by a non-type decl in a few cases where it
1171 // seems likely a type is wanted instead of the non-type that was found.
1172 bool NextIsOp = NextToken.isOneOf(tok::amp, tok::star);
1173 if ((NextToken.is(tok::identifier) ||
1174 (NextIsOp &&
1176 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
1177 TypeDecl *Type = Result.getAsSingle<TypeDecl>();
1178 DiagnoseUseOfDecl(Type, NameLoc);
1180 if (SS.isNotEmpty())
1181 return buildNestedType(*this, SS, T, NameLoc);
1182 return ParsedType::make(T);
1183 }
1184
1185 // If we already know which single declaration is referenced, just annotate
1186 // that declaration directly. Defer resolving even non-overloaded class
1187 // member accesses, as we need to defer certain access checks until we know
1188 // the context.
1189 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
1190 if (Result.isSingleResult() && !ADL && !FirstDecl->isCXXClassMember())
1191 return NameClassification::NonType(Result.getRepresentativeDecl());
1192
1193 // Otherwise, this is an overload set that we will need to resolve later.
1194 Result.suppressDiagnostics();
1196 Context, Result.getNamingClass(), SS.getWithLocInContext(Context),
1197 Result.getLookupNameInfo(), ADL, Result.isOverloadedResult(),
1198 Result.begin(), Result.end()));
1199}
1200
1203 SourceLocation NameLoc) {
1204 assert(getLangOpts().CPlusPlus && "ADL-only call in C?");
1205 CXXScopeSpec SS;
1206 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
1207 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true);
1208}
1209
1212 IdentifierInfo *Name,
1213 SourceLocation NameLoc,
1214 bool IsAddressOfOperand) {
1215 DeclarationNameInfo NameInfo(Name, NameLoc);
1216 return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(),
1217 NameInfo, IsAddressOfOperand,
1218 /*TemplateArgs=*/nullptr);
1219}
1220
1222 NamedDecl *Found,
1223 SourceLocation NameLoc,
1224 const Token &NextToken) {
1225 if (getCurMethodDecl() && SS.isEmpty())
1226 if (auto *Ivar = dyn_cast<ObjCIvarDecl>(Found->getUnderlyingDecl()))
1227 return BuildIvarRefExpr(S, NameLoc, Ivar);
1228
1229 // Reconstruct the lookup result.
1230 LookupResult Result(*this, Found->getDeclName(), NameLoc, LookupOrdinaryName);
1231 Result.addDecl(Found);
1232 Result.resolveKind();
1233
1234 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
1235 return BuildDeclarationNameExpr(SS, Result, ADL);
1236}
1237
1239 // For an implicit class member access, transform the result into a member
1240 // access expression if necessary.
1241 auto *ULE = cast<UnresolvedLookupExpr>(E);
1242 if ((*ULE->decls_begin())->isCXXClassMember()) {
1243 CXXScopeSpec SS;
1244 SS.Adopt(ULE->getQualifierLoc());
1245
1246 // Reconstruct the lookup result.
1247 LookupResult Result(*this, ULE->getName(), ULE->getNameLoc(),
1249 Result.setNamingClass(ULE->getNamingClass());
1250 for (auto I = ULE->decls_begin(), E = ULE->decls_end(); I != E; ++I)
1251 Result.addDecl(*I, I.getAccess());
1252 Result.resolveKind();
1254 nullptr, S);
1255 }
1256
1257 // Otherwise, this is already in the form we needed, and no further checks
1258 // are necessary.
1259 return ULE;
1260}
1261
1264 auto *TD = Name.getAsTemplateDecl();
1265 if (!TD)
1267 if (isa<ClassTemplateDecl>(TD))
1269 if (isa<FunctionTemplateDecl>(TD))
1271 if (isa<VarTemplateDecl>(TD))
1273 if (isa<TypeAliasTemplateDecl>(TD))
1275 if (isa<TemplateTemplateParmDecl>(TD))
1277 if (isa<ConceptDecl>(TD))
1280}
1281
1283 assert(DC->getLexicalParent() == CurContext &&
1284 "The next DeclContext should be lexically contained in the current one.");
1285 CurContext = DC;
1286 S->setEntity(DC);
1287}
1288
1290 assert(CurContext && "DeclContext imbalance!");
1291
1293 assert(CurContext && "Popped translation unit!");
1294}
1295
1297 Decl *D) {
1298 // Unlike PushDeclContext, the context to which we return is not necessarily
1299 // the containing DC of TD, because the new context will be some pre-existing
1300 // TagDecl definition instead of a fresh one.
1301 auto Result = static_cast<SkippedDefinitionContext>(CurContext);
1302 CurContext = cast<TagDecl>(D)->getDefinition();
1303 assert(CurContext && "skipping definition of undefined tag");
1304 // Start lookups from the parent of the current context; we don't want to look
1305 // into the pre-existing complete definition.
1306 S->setEntity(CurContext->getLookupParent());
1307 return Result;
1308}
1309
1313
1314/// EnterDeclaratorContext - Used when we must lookup names in the context
1315/// of a declarator's nested name specifier.
1316///
1318 // C++0x [basic.lookup.unqual]p13:
1319 // A name used in the definition of a static data member of class
1320 // X (after the qualified-id of the static member) is looked up as
1321 // if the name was used in a member function of X.
1322 // C++0x [basic.lookup.unqual]p14:
1323 // If a variable member of a namespace is defined outside of the
1324 // scope of its namespace then any name used in the definition of
1325 // the variable member (after the declarator-id) is looked up as
1326 // if the definition of the variable member occurred in its
1327 // namespace.
1328 // Both of these imply that we should push a scope whose context
1329 // is the semantic context of the declaration. We can't use
1330 // PushDeclContext here because that context is not necessarily
1331 // lexically contained in the current context. Fortunately,
1332 // the containing scope should have the appropriate information.
1333
1334 assert(!S->getEntity() && "scope already has entity");
1335
1336#ifndef NDEBUG
1337 Scope *Ancestor = S->getParent();
1338 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1339 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
1340#endif
1341
1342 CurContext = DC;
1343 S->setEntity(DC);
1344
1345 if (S->getParent()->isTemplateParamScope()) {
1346 // Also set the corresponding entities for all immediately-enclosing
1347 // template parameter scopes.
1348 EnterTemplatedContext(S->getParent(), DC);
1349 }
1350}
1351
1353 assert(S->getEntity() == CurContext && "Context imbalance!");
1354
1355 // Switch back to the lexical context. The safety of this is
1356 // enforced by an assert in EnterDeclaratorContext.
1357 Scope *Ancestor = S->getParent();
1358 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1359 CurContext = Ancestor->getEntity();
1360
1361 // We don't need to do anything with the scope, which is going to
1362 // disappear.
1363}
1364
1366 assert(S->isTemplateParamScope() &&
1367 "expected to be initializing a template parameter scope");
1368
1369 // C++20 [temp.local]p7:
1370 // In the definition of a member of a class template that appears outside
1371 // of the class template definition, the name of a member of the class
1372 // template hides the name of a template-parameter of any enclosing class
1373 // templates (but not a template-parameter of the member if the member is a
1374 // class or function template).
1375 // C++20 [temp.local]p9:
1376 // In the definition of a class template or in the definition of a member
1377 // of such a template that appears outside of the template definition, for
1378 // each non-dependent base class (13.8.2.1), if the name of the base class
1379 // or the name of a member of the base class is the same as the name of a
1380 // template-parameter, the base class name or member name hides the
1381 // template-parameter name (6.4.10).
1382 //
1383 // This means that a template parameter scope should be searched immediately
1384 // after searching the DeclContext for which it is a template parameter
1385 // scope. For example, for
1386 // template<typename T> template<typename U> template<typename V>
1387 // void N::A<T>::B<U>::f(...)
1388 // we search V then B<U> (and base classes) then U then A<T> (and base
1389 // classes) then T then N then ::.
1390 unsigned ScopeDepth = getTemplateDepth(S);
1391 for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) {
1392 DeclContext *SearchDCAfterScope = DC;
1393 for (; DC; DC = DC->getLookupParent()) {
1394 if (const TemplateParameterList *TPL =
1395 cast<Decl>(DC)->getDescribedTemplateParams()) {
1396 unsigned DCDepth = TPL->getDepth() + 1;
1397 if (DCDepth > ScopeDepth)
1398 continue;
1399 if (ScopeDepth == DCDepth)
1400 SearchDCAfterScope = DC = DC->getLookupParent();
1401 break;
1402 }
1403 }
1404 S->setLookupEntity(SearchDCAfterScope);
1405 }
1406}
1407
1409 // We assume that the caller has already called
1410 // ActOnReenterTemplateScope so getTemplatedDecl() works.
1411 FunctionDecl *FD = D->getAsFunction();
1412 if (!FD)
1413 return;
1414
1415 // Same implementation as PushDeclContext, but enters the context
1416 // from the lexical parent, rather than the top-level class.
1417 assert(CurContext == FD->getLexicalParent() &&
1418 "The next DeclContext should be lexically contained in the current one.");
1419 CurContext = FD;
1420 S->setEntity(CurContext);
1421
1422 for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
1423 ParmVarDecl *Param = FD->getParamDecl(P);
1424 // If the parameter has an identifier, then add it to the scope
1425 if (Param->getIdentifier()) {
1426 S->AddDecl(Param);
1427 IdResolver.AddDecl(Param);
1428 }
1429 }
1430}
1431
1433 // Same implementation as PopDeclContext, but returns to the lexical parent,
1434 // rather than the top-level class.
1435 assert(CurContext && "DeclContext imbalance!");
1437 assert(CurContext && "Popped translation unit!");
1438}
1439
1440/// Determine whether we allow overloading of the function
1441/// PrevDecl with another declaration.
1442///
1443/// This routine determines whether overloading is possible, not
1444/// whether some new function is actually an overload. It will return
1445/// true in C++ (where we can always provide overloads) or, as an
1446/// extension, in C when the previous function is already an
1447/// overloaded function declaration or has the "overloadable"
1448/// attribute.
1450 ASTContext &Context,
1451 const FunctionDecl *New) {
1452 if (Context.getLangOpts().CPlusPlus)
1453 return true;
1454
1455 if (Previous.getResultKind() == LookupResult::FoundOverloaded)
1456 return true;
1457
1458 return Previous.getResultKind() == LookupResult::Found &&
1459 (Previous.getFoundDecl()->hasAttr<OverloadableAttr>() ||
1460 New->hasAttr<OverloadableAttr>());
1461}
1462
1463/// Add this decl to the scope shadowed decl chains.
1464void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
1465 // Move up the scope chain until we find the nearest enclosing
1466 // non-transparent context. The declaration will be introduced into this
1467 // scope.
1468 while (S->getEntity() && S->getEntity()->isTransparentContext())
1469 S = S->getParent();
1470
1471 // Add scoped declarations into their context, so that they can be
1472 // found later. Declarations without a context won't be inserted
1473 // into any context.
1474 if (AddToContext)
1475 CurContext->addDecl(D);
1476
1477 // Out-of-line definitions shouldn't be pushed into scope in C++, unless they
1478 // are function-local declarations.
1479 if (getLangOpts().CPlusPlus && D->isOutOfLine() && !S->getFnParent())
1480 return;
1481
1482 // Template instantiations should also not be pushed into scope.
1483 if (isa<FunctionDecl>(D) &&
1484 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1485 return;
1486
1487 // If this replaces anything in the current scope,
1489 IEnd = IdResolver.end();
1490 for (; I != IEnd; ++I) {
1491 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
1492 S->RemoveDecl(*I);
1494
1495 // Should only need to replace one decl.
1496 break;
1497 }
1498 }
1499
1500 S->AddDecl(D);
1501
1502 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1503 // Implicitly-generated labels may end up getting generated in an order that
1504 // isn't strictly lexical, which breaks name lookup. Be careful to insert
1505 // the label at the appropriate place in the identifier chain.
1506 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
1507 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();
1508 if (IDC == CurContext) {
1509 if (!S->isDeclScope(*I))
1510 continue;
1511 } else if (IDC->Encloses(CurContext))
1512 break;
1513 }
1514
1516 } else {
1518 }
1519}
1520
1522 bool AllowInlineNamespace) {
1523 return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace);
1524}
1525
1527 DeclContext *TargetDC = DC->getPrimaryContext();
1528 do {
1529 if (DeclContext *ScopeDC = S->getEntity())
1530 if (ScopeDC->getPrimaryContext() == TargetDC)
1531 return S;
1532 } while ((S = S->getParent()));
1533
1534 return nullptr;
1535}
1536
1538 DeclContext*,
1539 ASTContext&);
1540
1541/// Filters out lookup results that don't fall within the given scope
1542/// as determined by isDeclInScope.
1544 bool ConsiderLinkage,
1545 bool AllowInlineNamespace) {
1547 while (F.hasNext()) {
1548 NamedDecl *D = F.next();
1549
1550 if (isDeclInScope(D, Ctx, S, AllowInlineNamespace))
1551 continue;
1552
1553 if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context))
1554 continue;
1555
1556 F.erase();
1557 }
1558
1559 F.done();
1560}
1561
1562/// We've determined that \p New is a redeclaration of \p Old. Check that they
1563/// have compatible owning modules.
1565 // FIXME: The Modules TS is not clear about how friend declarations are
1566 // to be treated. It's not meaningful to have different owning modules for
1567 // linkage in redeclarations of the same entity, so for now allow the
1568 // redeclaration and change the owning modules to match.
1569 if (New->getFriendObjectKind() &&
1573 return false;
1574 }
1575
1576 Module *NewM = New->getOwningModule();
1577 Module *OldM = Old->getOwningModule();
1578
1579 if (NewM && NewM->Kind == Module::PrivateModuleFragment)
1580 NewM = NewM->Parent;
1581 if (OldM && OldM->Kind == Module::PrivateModuleFragment)
1582 OldM = OldM->Parent;
1583
1584 if (NewM == OldM)
1585 return false;
1586
1587 bool NewIsModuleInterface = NewM && NewM->isModulePurview();
1588 bool OldIsModuleInterface = OldM && OldM->isModulePurview();
1589 if (NewIsModuleInterface || OldIsModuleInterface) {
1590 // C++ Modules TS [basic.def.odr] 6.2/6.7 [sic]:
1591 // if a declaration of D [...] appears in the purview of a module, all
1592 // other such declarations shall appear in the purview of the same module
1593 Diag(New->getLocation(), diag::err_mismatched_owning_module)
1594 << New
1595 << NewIsModuleInterface
1596 << (NewIsModuleInterface ? NewM->getFullModuleName() : "")
1597 << OldIsModuleInterface
1598 << (OldIsModuleInterface ? OldM->getFullModuleName() : "");
1599 Diag(Old->getLocation(), diag::note_previous_declaration);
1600 New->setInvalidDecl();
1601 return true;
1602 }
1603
1604 return false;
1605}
1606
1612
1613/// Removes using shadow declarations from the lookup results.
1616 while (F.hasNext())
1617 if (isUsingDecl(F.next()))
1618 F.erase();
1619
1620 F.done();
1621}
1622
1623/// Check for this common pattern:
1624/// @code
1625/// class S {
1626/// S(const S&); // DO NOT IMPLEMENT
1627/// void operator=(const S&); // DO NOT IMPLEMENT
1628/// };
1629/// @endcode
1631 // FIXME: Should check for private access too but access is set after we get
1632 // the decl here.
1634 return false;
1635
1636 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
1637 return CD->isCopyConstructor();
1638 return D->isCopyAssignmentOperator();
1639}
1640
1641// We need this to handle
1642//
1643// typedef struct {
1644// void *foo() { return 0; }
1645// } A;
1646//
1647// When we see foo we don't know if after the typedef we will get 'A' or '*A'
1648// for example. If 'A', foo will have external linkage. If we have '*A',
1649// foo will have no linkage. Since we can't know until we get to the end
1650// of the typedef, this function finds out if D might have non-external linkage.
1651// Callers should verify at the end of the TU if it D has external linkage or
1652// not.
1653bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) {
1654 const DeclContext *DC = D->getDeclContext();
1655 while (!DC->isTranslationUnit()) {
1656 if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1657 if (!RD->hasNameForLinkage())
1658 return true;
1659 }
1660 DC = DC->getParent();
1661 }
1662
1663 return !D->isExternallyVisible();
1664}
1665
1666// FIXME: This needs to be refactored; some other isInMainFile users want
1667// these semantics.
1668static bool isMainFileLoc(const Sema &S, SourceLocation Loc) {
1669 if (S.TUKind != TU_Complete)
1670 return false;
1671 return S.SourceMgr.isInMainFile(Loc);
1672}
1673
1675 assert(D);
1676
1677 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
1678 return false;
1679
1680 // Ignore all entities declared within templates, and out-of-line definitions
1681 // of members of class templates.
1682 if (D->getDeclContext()->isDependentContext() ||
1684 return false;
1685
1686 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1687 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1688 return false;
1689 // A non-out-of-line declaration of a member specialization was implicitly
1690 // instantiated; it's the out-of-line declaration that we're interested in.
1691 if (FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
1692 FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1693 return false;
1694
1695 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1696 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD))
1697 return false;
1698 } else {
1699 // 'static inline' functions are defined in headers; don't warn.
1700 if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation()))
1701 return false;
1702 }
1703
1704 if (FD->doesThisDeclarationHaveABody() &&
1706 return false;
1707 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1708 // Constants and utility variables are defined in headers with internal
1709 // linkage; don't warn. (Unlike functions, there isn't a convenient marker
1710 // like "inline".)
1711 if (!isMainFileLoc(*this, VD->getLocation()))
1712 return false;
1713
1714 if (Context.DeclMustBeEmitted(VD))
1715 return false;
1716
1717 if (VD->isStaticDataMember() &&
1718 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1719 return false;
1720 if (VD->isStaticDataMember() &&
1721 VD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
1722 VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1723 return false;
1724
1725 if (VD->isInline() && !isMainFileLoc(*this, VD->getLocation()))
1726 return false;
1727 } else {
1728 return false;
1729 }
1730
1731 // Only warn for unused decls internal to the translation unit.
1732 // FIXME: This seems like a bogus check; it suppresses -Wunused-function
1733 // for inline functions defined in the main source file, for instance.
1734 return mightHaveNonExternalLinkage(D);
1735}
1736
1738 if (!D)
1739 return;
1740
1741 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1742 const FunctionDecl *First = FD->getFirstDecl();
1744 return; // First should already be in the vector.
1745 }
1746
1747 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1748 const VarDecl *First = VD->getFirstDecl();
1750 return; // First should already be in the vector.
1751 }
1752
1755}
1756
1758 if (D->isInvalidDecl())
1759 return false;
1760
1761 if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
1762 // For a decomposition declaration, warn if none of the bindings are
1763 // referenced, instead of if the variable itself is referenced (which
1764 // it is, by the bindings' expressions).
1765 for (auto *BD : DD->bindings())
1766 if (BD->isReferenced())
1767 return false;
1768 } else if (!D->getDeclName()) {
1769 return false;
1770 } else if (D->isReferenced() || D->isUsed()) {
1771 return false;
1772 }
1773
1775 return false;
1776
1777 if (isa<LabelDecl>(D))
1778 return true;
1779
1780 // Except for labels, we only care about unused decls that are local to
1781 // functions.
1782 bool WithinFunction = D->getDeclContext()->isFunctionOrMethod();
1783 if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
1784 // For dependent types, the diagnostic is deferred.
1785 WithinFunction =
1786 WithinFunction || (R->isLocalClass() && !R->isDependentType());
1787 if (!WithinFunction)
1788 return false;
1789
1790 if (isa<TypedefNameDecl>(D))
1791 return true;
1792
1793 // White-list anything that isn't a local variable.
1794 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
1795 return false;
1796
1797 // Types of valid local variables should be complete, so this should succeed.
1798 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1799
1800 // White-list anything with an __attribute__((unused)) type.
1801 const auto *Ty = VD->getType().getTypePtr();
1802
1803 // Only look at the outermost level of typedef.
1804 if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
1805 if (TT->getDecl()->hasAttr<UnusedAttr>())
1806 return false;
1807 }
1808
1809 // If we failed to complete the type for some reason, or if the type is
1810 // dependent, don't diagnose the variable.
1811 if (Ty->isIncompleteType() || Ty->isDependentType())
1812 return false;
1813
1814 // Look at the element type to ensure that the warning behaviour is
1815 // consistent for both scalars and arrays.
1816 Ty = Ty->getBaseElementTypeUnsafe();
1817
1818 if (const TagType *TT = Ty->getAs<TagType>()) {
1819 const TagDecl *Tag = TT->getDecl();
1820 if (Tag->hasAttr<UnusedAttr>())
1821 return false;
1822
1823 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
1824 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
1825 return false;
1826
1827 if (const Expr *Init = VD->getInit()) {
1828 if (const ExprWithCleanups *Cleanups =
1829 dyn_cast<ExprWithCleanups>(Init))
1830 Init = Cleanups->getSubExpr();
1831 const CXXConstructExpr *Construct =
1832 dyn_cast<CXXConstructExpr>(Init);
1833 if (Construct && !Construct->isElidable()) {
1834 CXXConstructorDecl *CD = Construct->getConstructor();
1835 if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
1836 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
1837 return false;
1838 }
1839
1840 // Suppress the warning if we don't know how this is constructed, and
1841 // it could possibly be non-trivial constructor.
1842 if (Init->isTypeDependent())
1843 for (const CXXConstructorDecl *Ctor : RD->ctors())
1844 if (!Ctor->isTrivial())
1845 return false;
1846 }
1847 }
1848 }
1849
1850 // TODO: __attribute__((unused)) templates?
1851 }
1852
1853 return true;
1854}
1855
1857 FixItHint &Hint) {
1858 if (isa<LabelDecl>(D)) {
1860 D->getEndLoc(), tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(),
1861 true);
1862 if (AfterColon.isInvalid())
1863 return;
1865 CharSourceRange::getCharRange(D->getBeginLoc(), AfterColon));
1866 }
1867}
1868
1870 if (D->getTypeForDecl()->isDependentType())
1871 return;
1872
1873 for (auto *TmpD : D->decls()) {
1874 if (const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
1876 else if(const auto *R = dyn_cast<RecordDecl>(TmpD))
1878 }
1879}
1880
1881/// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
1882/// unless they are marked attr(unused).
1885 return;
1886
1887 if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
1888 // typedefs can be referenced later on, so the diagnostics are emitted
1889 // at end-of-translation-unit.
1891 return;
1892 }
1893
1894 FixItHint Hint;
1896
1897 unsigned DiagID;
1898 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
1899 DiagID = diag::warn_unused_exception_param;
1900 else if (isa<LabelDecl>(D))
1901 DiagID = diag::warn_unused_label;
1902 else
1903 DiagID = diag::warn_unused_variable;
1904
1905 Diag(D->getLocation(), DiagID) << D << Hint;
1906}
1907
1908static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
1909 // Verify that we have no forward references left. If so, there was a goto
1910 // or address of a label taken, but no definition of it. Label fwd
1911 // definitions are indicated with a null substmt which is also not a resolved
1912 // MS inline assembly label name.
1913 bool Diagnose = false;
1914 if (L->isMSAsmLabel())
1915 Diagnose = !L->isResolvedMSAsmLabel();
1916 else
1917 Diagnose = L->getStmt() == nullptr;
1918 if (Diagnose)
1919 S.Diag(L->getLocation(), diag::err_undeclared_label_use) << L;
1920}
1921
1923 S->mergeNRVOIntoParent();
1924
1925 if (S->decl_empty()) return;
1926 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
1927 "Scope shouldn't contain decls!");
1928
1929 for (auto *TmpD : S->decls()) {
1930 assert(TmpD && "This decl didn't get pushed??");
1931
1932 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
1933 NamedDecl *D = cast<NamedDecl>(TmpD);
1934
1935 // Diagnose unused variables in this scope.
1936 if (!S->hasUnrecoverableErrorOccurred()) {
1938 if (const auto *RD = dyn_cast<RecordDecl>(D))
1940 }
1941
1942 if (!D->getDeclName()) continue;
1943
1944 // If this was a forward reference to a label, verify it was defined.
1945 if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
1946 CheckPoppedLabel(LD, *this);
1947
1948 // Remove this name from our lexical scope, and warn on it if we haven't
1949 // already.
1951 auto ShadowI = ShadowingDecls.find(D);
1952 if (ShadowI != ShadowingDecls.end()) {
1953 if (const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
1954 Diag(D->getLocation(), diag::warn_ctor_parm_shadows_field)
1955 << D << FD << FD->getParent();
1956 Diag(FD->getLocation(), diag::note_previous_declaration);
1957 }
1958 ShadowingDecls.erase(ShadowI);
1959 }
1960 }
1961}
1962
1963/// Look for an Objective-C class in the translation unit.
1964///
1965/// \param Id The name of the Objective-C class we're looking for. If
1966/// typo-correction fixes this name, the Id will be updated
1967/// to the fixed name.
1968///
1969/// \param IdLoc The location of the name in the translation unit.
1970///
1971/// \param DoTypoCorrection If true, this routine will attempt typo correction
1972/// if there is no class with the given name.
1973///
1974/// \returns The declaration of the named Objective-C class, or NULL if the
1975/// class could not be found.
1977 SourceLocation IdLoc,
1978 bool DoTypoCorrection) {
1979 // The third "scope" argument is 0 since we aren't enabling lazy built-in
1980 // creation from this context.
1982
1983 if (!IDecl && DoTypoCorrection) {
1984 // Perform typo correction at the given location, but only if we
1985 // find an Objective-C class name.
1987 if (TypoCorrection C =
1989 TUScope, nullptr, CCC, CTK_ErrorRecovery)) {
1990 diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id);
1991 IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>();
1992 Id = IDecl->getIdentifier();
1993 }
1994 }
1995 ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
1996 // This routine must always return a class definition, if any.
1997 if (Def && Def->getDefinition())
1998 Def = Def->getDefinition();
1999 return Def;
2000}
2001
2002/// getNonFieldDeclScope - Retrieves the innermost scope, starting
2003/// from S, where a non-field would be declared. This routine copes
2004/// with the difference between C and C++ scoping rules in structs and
2005/// unions. For example, the following code is well-formed in C but
2006/// ill-formed in C++:
2007/// @code
2008/// struct S6 {
2009/// enum { BAR } e;
2010/// };
2011///
2012/// void test_S6() {
2013/// struct S6 a;
2014/// a.e = BAR;
2015/// }
2016/// @endcode
2017/// For the declaration of BAR, this routine will return a different
2018/// scope. The scope S will be the scope of the unnamed enumeration
2019/// within S6. In C++, this routine will return the scope associated
2020/// with S6, because the enumeration's scope is a transparent
2021/// context but structures can contain non-field names. In C, this
2022/// routine will return the translation unit scope, since the
2023/// enumeration's scope is a transparent context and structures cannot
2024/// contain non-field names.
2026 while (((S->getFlags() & Scope::DeclScope) == 0) ||
2027 (S->getEntity() && S->getEntity()->isTransparentContext()) ||
2028 (S->isClassScope() && !getLangOpts().CPlusPlus))
2029 S = S->getParent();
2030 return S;
2031}
2032
2033static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID,
2035 switch (Error) {
2037 return "";
2039 return BuiltinInfo.getHeaderName(ID);
2041 return "stdio.h";
2043 return "setjmp.h";
2045 return "ucontext.h";
2046 }
2047 llvm_unreachable("unhandled error kind");
2048}
2049
2051 unsigned ID, SourceLocation Loc) {
2053
2054 if (getLangOpts().CPlusPlus) {
2056 Context, Parent, Loc, Loc, LinkageSpecDecl::lang_c, false);
2057 CLinkageDecl->setImplicit();
2058 Parent->addDecl(CLinkageDecl);
2059 Parent = CLinkageDecl;
2060 }
2061
2062 FunctionDecl *New = FunctionDecl::Create(Context, Parent, Loc, Loc, II, Type,
2063 /*TInfo=*/nullptr, SC_Extern, false,
2065 New->setImplicit();
2067
2068 // Create Decl objects for each parameter, adding them to the
2069 // FunctionDecl.
2070 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(Type)) {
2072 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2074 Context, New, SourceLocation(), SourceLocation(), nullptr,
2075 FT->getParamType(i), /*TInfo=*/nullptr, SC_None, nullptr);
2076 parm->setScopeInfo(0, i);
2077 Params.push_back(parm);
2078 }
2079 New->setParams(Params);
2080 }
2081
2083 return New;
2084}
2085
2086/// LazilyCreateBuiltin - The specified Builtin-ID was first used at
2087/// file scope. lazily create a decl for it. ForRedeclaration is true
2088/// if we're creating this built-in in anticipation of redeclaring the
2089/// built-in.
2091 Scope *S, bool ForRedeclaration,
2092 SourceLocation Loc) {
2094
2096 QualType R = Context.GetBuiltinType(ID, Error);
2097 if (Error) {
2098 if (!ForRedeclaration)
2099 return nullptr;
2100
2101 // If we have a builtin without an associated type we should not emit a
2102 // warning when we were not able to find a type for it.
2103 if (Error == ASTContext::GE_Missing_type ||
2105 return nullptr;
2106
2107 // If we could not find a type for setjmp it is because the jmp_buf type was
2108 // not defined prior to the setjmp declaration.
2109 if (Error == ASTContext::GE_Missing_setjmp) {
2110 Diag(Loc, diag::warn_implicit_decl_no_jmp_buf)
2112 return nullptr;
2113 }
2114
2115 // Generally, we emit a warning that the declaration requires the
2116 // appropriate header.
2117 Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
2118 << getHeaderName(Context.BuiltinInfo, ID, Error)
2120 return nullptr;
2121 }
2122
2123 if (!ForRedeclaration &&
2126 Diag(Loc, diag::ext_implicit_lib_function_decl)
2127 << Context.BuiltinInfo.getName(ID) << R;
2128 if (const char *Header = Context.BuiltinInfo.getHeaderName(ID))
2129 Diag(Loc, diag::note_include_header_or_declare)
2130 << Header << Context.BuiltinInfo.getName(ID);
2131 }
2132
2133 if (R.isNull())
2134 return nullptr;
2135
2136 FunctionDecl *New = CreateBuiltin(II, R, ID, Loc);
2138
2139 // TUScope is the translation-unit scope to insert this function into.
2140 // FIXME: This is hideous. We need to teach PushOnScopeChains to
2141 // relate Scopes to DeclContexts, and probably eliminate CurContext
2142 // entirely, but we're not there yet.
2143 DeclContext *SavedContext = CurContext;
2144 CurContext = New->getDeclContext();
2146 CurContext = SavedContext;
2147 return New;
2148}
2149
2150/// Typedef declarations don't have linkage, but they still denote the same
2151/// entity if their types are the same.
2152/// FIXME: This is notionally doing the same thing as ASTReaderDecl's
2153/// isSameEntity.
2157 // This is only interesting when modules are enabled.
2158 if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility)
2159 return;
2160
2161 // Empty sets are uninteresting.
2162 if (Previous.empty())
2163 return;
2164
2165 LookupResult::Filter Filter = Previous.makeFilter();
2166 while (Filter.hasNext()) {
2167 NamedDecl *Old = Filter.next();
2168
2169 // Non-hidden declarations are never ignored.
2170 if (S.isVisible(Old))
2171 continue;
2172
2173 // Declarations of the same entity are not ignored, even if they have
2174 // different linkages.
2175 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2176 if (S.Context.hasSameType(OldTD->getUnderlyingType(),
2177 Decl->getUnderlyingType()))
2178 continue;
2179
2180 // If both declarations give a tag declaration a typedef name for linkage
2181 // purposes, then they declare the same entity.
2182 if (OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true) &&
2183 Decl->getAnonDeclWithTypedefName())
2184 continue;
2185 }
2186
2187 Filter.erase();
2188 }
2189
2190 Filter.done();
2191}
2192
2194 QualType OldType;
2195 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
2196 OldType = OldTypedef->getUnderlyingType();
2197 else
2198 OldType = Context.getTypeDeclType(Old);
2199 QualType NewType = New->getUnderlyingType();
2200
2201 if (NewType->isVariablyModifiedType()) {
2202 // Must not redefine a typedef with a variably-modified type.
2203 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2204 Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
2205 << Kind << NewType;
2206 if (Old->getLocation().isValid())
2208 New->setInvalidDecl();
2209 return true;
2210 }
2211
2212 if (OldType != NewType &&
2213 !OldType->isDependentType() &&
2214 !NewType->isDependentType() &&
2215 !Context.hasSameType(OldType, NewType)) {
2216 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2217 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
2218 << Kind << NewType << OldType;
2219 if (Old->getLocation().isValid())
2221 New->setInvalidDecl();
2222 return true;
2223 }
2224 return false;
2225}
2226
2227/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
2228/// same name and scope as a previous declaration 'Old'. Figure out
2229/// how to resolve this situation, merging decls or emitting
2230/// diagnostics as appropriate. If there was an error, set New to be invalid.
2231///
2233 LookupResult &OldDecls) {
2234 // If the new decl is known invalid already, don't bother doing any
2235 // merging checks.
2236 if (New->isInvalidDecl()) return;
2237
2238 // Allow multiple definitions for ObjC built-in typedefs.
2239 // FIXME: Verify the underlying types are equivalent!
2240 if (getLangOpts().ObjC) {
2241 const IdentifierInfo *TypeID = New->getIdentifier();
2242 switch (TypeID->getLength()) {
2243 default: break;
2244 case 2:
2245 {
2246 if (!TypeID->isStr("id"))
2247 break;
2248 QualType T = New->getUnderlyingType();
2249 if (!T->isPointerType())
2250 break;
2251 if (!T->isVoidPointerType()) {
2252 QualType PT = T->castAs<PointerType>()->getPointeeType();
2253 if (!PT->isStructureType())
2254 break;
2255 }
2257 // Install the built-in type for 'id', ignoring the current definition.
2259 return;
2260 }
2261 case 5:
2262 if (!TypeID->isStr("Class"))
2263 break;
2265 // Install the built-in type for 'Class', ignoring the current definition.
2267 return;
2268 case 3:
2269 if (!TypeID->isStr("SEL"))
2270 break;
2272 // Install the built-in type for 'SEL', ignoring the current definition.
2274 return;
2275 }
2276 // Fall through - the typedef name was not a builtin type.
2277 }
2278
2279 // Verify the old decl was also a type.
2280 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
2281 if (!Old) {
2282 Diag(New->getLocation(), diag::err_redefinition_different_kind)
2283 << New->getDeclName();
2284
2285 NamedDecl *OldD = OldDecls.getRepresentativeDecl();
2286 if (OldD->getLocation().isValid())
2287 notePreviousDefinition(OldD, New->getLocation());
2288
2289 return New->setInvalidDecl();
2290 }
2291
2292 // If the old declaration is invalid, just give up here.
2293 if (Old->isInvalidDecl())
2294 return New->setInvalidDecl();
2295
2296 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2297 auto *OldTag = OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true);
2298 auto *NewTag = New->getAnonDeclWithTypedefName();
2299 NamedDecl *Hidden = nullptr;
2300 if (OldTag && NewTag &&
2301 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2302 !hasVisibleDefinition(OldTag, &Hidden)) {
2303 // There is a definition of this tag, but it is not visible. Use it
2304 // instead of our tag.
2305 New->setTypeForDecl(OldTD->getTypeForDecl());
2306 if (OldTD->isModed())
2307 New->setModedTypeSourceInfo(OldTD->getTypeSourceInfo(),
2308 OldTD->getUnderlyingType());
2309 else
2310 New->setTypeSourceInfo(OldTD->getTypeSourceInfo());
2311
2312 // Make the old tag definition visible.
2314
2315 // If this was an unscoped enumeration, yank all of its enumerators
2316 // out of the scope.
2317 if (isa<EnumDecl>(NewTag)) {
2318 Scope *EnumScope = getNonFieldDeclScope(S);
2319 for (auto *D : NewTag->decls()) {
2320 auto *ED = cast<EnumConstantDecl>(D);
2321 assert(EnumScope->isDeclScope(ED));
2322 EnumScope->RemoveDecl(ED);
2324 ED->getLexicalDeclContext()->removeDecl(ED);
2325 }
2326 }
2327 }
2328 }
2329
2330 // If the typedef types are not identical, reject them in all languages and
2331 // with any extensions enabled.
2332 if (isIncompatibleTypedef(Old, New))
2333 return;
2334
2335 // The types match. Link up the redeclaration chain and merge attributes if
2336 // the old declaration was a typedef.
2337 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) {
2338 New->setPreviousDecl(Typedef);
2339 mergeDeclAttributes(New, Old);
2340 }
2341
2342 if (getLangOpts().MicrosoftExt)
2343 return;
2344
2345 if (getLangOpts().CPlusPlus) {
2346 // C++ [dcl.typedef]p2:
2347 // In a given non-class scope, a typedef specifier can be used to
2348 // redefine the name of any type declared in that scope to refer
2349 // to the type to which it already refers.
2350 if (!isa<CXXRecordDecl>(CurContext))
2351 return;
2352
2353 // C++0x [dcl.typedef]p4:
2354 // In a given class scope, a typedef specifier can be used to redefine
2355 // any class-name declared in that scope that is not also a typedef-name
2356 // to refer to the type to which it already refers.
2357 //
2358 // This wording came in via DR424, which was a correction to the
2359 // wording in DR56, which accidentally banned code like:
2360 //
2361 // struct S {
2362 // typedef struct A { } A;
2363 // };
2364 //
2365 // in the C++03 standard. We implement the C++0x semantics, which
2366 // allow the above but disallow
2367 //
2368 // struct S {
2369 // typedef int I;
2370 // typedef int I;
2371 // };
2372 //
2373 // since that was the intent of DR56.
2374 if (!isa<TypedefNameDecl>(Old))
2375 return;
2376
2377 Diag(New->getLocation(), diag::err_redefinition)
2378 << New->getDeclName();
2380 return New->setInvalidDecl();
2381 }
2382
2383 // Modules always permit redefinition of typedefs, as does C11.
2384 if (getLangOpts().Modules || getLangOpts().C11)
2385 return;
2386
2387 // If we have a redefinition of a typedef in C, emit a warning. This warning
2388 // is normally mapped to an error, but can be controlled with
2389 // -Wtypedef-redefinition. If either the original or the redefinition is
2390 // in a system header, don't emit this for compatibility with GCC.
2391 if (getDiagnostics().getSuppressSystemWarnings() &&
2392 // Some standard types are defined implicitly in Clang (e.g. OpenCL).
2393 (Old->isImplicit() ||
2396 return;
2397
2398 Diag(New->getLocation(), diag::ext_redefinition_of_typedef)
2399 << New->getDeclName();
2401}
2402
2403/// DeclhasAttr - returns true if decl Declaration already has the target
2404/// attribute.
2405static bool DeclHasAttr(const Decl *D, const Attr *A) {
2406 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2407 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2408 for (const auto *i : D->attrs())
2409 if (i->getKind() == A->getKind()) {
2410 if (Ann) {
2411 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2412 return true;
2413 continue;
2414 }
2415 // FIXME: Don't hardcode this check
2416 if (OA && isa<OwnershipAttr>(i))
2417 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2418 return true;
2419 }
2420
2421 return false;
2422}
2423
2425 if (VarDecl *VD = dyn_cast<VarDecl>(D))
2426 return VD->isThisDeclarationADefinition();
2427 if (TagDecl *TD = dyn_cast<TagDecl>(D))
2428 return TD->isCompleteDefinition() || TD->isBeingDefined();
2429 return true;
2430}
2431
2432/// Merge alignment attributes from \p Old to \p New, taking into account the
2433/// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
2434///
2435/// \return \c true if any attributes were added to \p New.
2436static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {
2437 // Look for alignas attributes on Old, and pick out whichever attribute
2438 // specifies the strictest alignment requirement.
2439 AlignedAttr *OldAlignasAttr = nullptr;
2440 AlignedAttr *OldStrictestAlignAttr = nullptr;
2441 unsigned OldAlign = 0;
2442 for (auto *I : Old->specific_attrs<AlignedAttr>()) {
2443 // FIXME: We have no way of representing inherited dependent alignments
2444 // in a case like:
2445 // template<int A, int B> struct alignas(A) X;
2446 // template<int A, int B> struct alignas(B) X {};
2447 // For now, we just ignore any alignas attributes which are not on the
2448 // definition in such a case.
2449 if (I->isAlignmentDependent())
2450 return false;
2451
2452 if (I->isAlignas())
2453 OldAlignasAttr = I;
2454
2455 unsigned Align = I->getAlignment(S.Context);
2456 if (Align > OldAlign) {
2457 OldAlign = Align;
2458 OldStrictestAlignAttr = I;
2459 }
2460 }
2461
2462 // Look for alignas attributes on New.
2463 AlignedAttr *NewAlignasAttr = nullptr;
2464 unsigned NewAlign = 0;
2465 for (auto *I : New->specific_attrs<AlignedAttr>()) {
2466 if (I->isAlignmentDependent())
2467 return false;
2468
2469 if (I->isAlignas())
2470 NewAlignasAttr = I;
2471
2472 unsigned Align = I->getAlignment(S.Context);
2473 if (Align > NewAlign)
2474 NewAlign = Align;
2475 }
2476
2477 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2478 // Both declarations have 'alignas' attributes. We require them to match.
2479 // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
2480 // fall short. (If two declarations both have alignas, they must both match
2481 // every definition, and so must match each other if there is a definition.)
2482
2483 // If either declaration only contains 'alignas(0)' specifiers, then it
2484 // specifies the natural alignment for the type.
2485 if (OldAlign == 0 || NewAlign == 0) {
2486 QualType Ty;
2487 if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
2488 Ty = VD->getType();
2489 else
2490 Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
2491
2492 if (OldAlign == 0)
2493 OldAlign = S.Context.getTypeAlign(Ty);
2494 if (NewAlign == 0)
2495 NewAlign = S.Context.getTypeAlign(Ty);
2496 }
2497
2498 if (OldAlign != NewAlign) {
2499 S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2502 S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2503 }
2504 }
2505
2506 if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
2507 // C++11 [dcl.align]p6:
2508 // if any declaration of an entity has an alignment-specifier,
2509 // every defining declaration of that entity shall specify an
2510 // equivalent alignment.
2511 // C11 6.7.5/7:
2512 // If the definition of an object does not have an alignment
2513 // specifier, any other declaration of that object shall also
2514 // have no alignment specifier.
2515 S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
2516 << OldAlignasAttr;
2517 S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2518 << OldAlignasAttr;
2519 }
2520
2521 bool AnyAdded = false;
2522
2523 // Ensure we have an attribute representing the strictest alignment.
2524 if (OldAlign > NewAlign) {
2525 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
2526 Clone->setInherited(true);
2527 New->addAttr(Clone);
2528 AnyAdded = true;
2529 }
2530
2531 // Ensure we have an alignas attribute if the old declaration had one.
2532 if (OldAlignasAttr && !NewAlignasAttr &&
2533 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2534 AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
2535 Clone->setInherited(true);
2536 New->addAttr(Clone);
2537 AnyAdded = true;
2538 }
2539
2540 return AnyAdded;
2541}
2542
2544 const InheritableAttr *Attr,
2546 // This function copies an attribute Attr from a previous declaration to the
2547 // new declaration D if the new declaration doesn't itself have that attribute
2548 // yet or if that attribute allows duplicates.
2549 // If you're adding a new attribute that requires logic different from
2550 // "use explicit attribute on decl if present, else use attribute from
2551 // previous decl", for example if the attribute needs to be consistent
2552 // between redeclarations, you need to call a custom merge function here.
2553 InheritableAttr *NewAttr = nullptr;
2554 if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
2555 NewAttr = S.mergeAvailabilityAttr(
2556 D, *AA, AA->getPlatform(), AA->isImplicit(), AA->getIntroduced(),
2557 AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(),
2558 AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK,
2559 AA->getPriority());
2560 else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
2561 NewAttr = S.mergeVisibilityAttr(D, *VA, VA->getVisibility());
2562 else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
2563 NewAttr = S.mergeTypeVisibilityAttr(D, *VA, VA->getVisibility());
2564 else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
2565 NewAttr = S.mergeDLLImportAttr(D, *ImportA);
2566 else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
2567 NewAttr = S.mergeDLLExportAttr(D, *ExportA);
2568 else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
2569 NewAttr = S.mergeFormatAttr(D, *FA, FA->getType(), FA->getFormatIdx(),
2570 FA->getFirstArg());
2571 else if (const auto *SA = dyn_cast<SectionAttr>(Attr))
2572 NewAttr = S.mergeSectionAttr(D, *SA, SA->getName());
2573 else if (const auto *CSA = dyn_cast<CodeSegAttr>(Attr))
2574 NewAttr = S.mergeCodeSegAttr(D, *CSA, CSA->getName());
2575 else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr))
2576 NewAttr = S.mergeMSInheritanceAttr(D, *IA, IA->getBestCase(),
2577 IA->getInheritanceModel());
2578 else if (const auto *AA = dyn_cast<AlwaysInlineAttr>(Attr))
2579 NewAttr = S.mergeAlwaysInlineAttr(D, *AA,
2580 &S.Context.Idents.get(AA->getSpelling()));
2581 else if (S.getLangOpts().CUDA && isa<FunctionDecl>(D) &&
2582 (isa<CUDAHostAttr>(Attr) || isa<CUDADeviceAttr>(Attr) ||
2583 isa<CUDAGlobalAttr>(Attr))) {
2584 // CUDA target attributes are part of function signature for
2585 // overloading purposes and must not be merged.
2586 return false;
2587 } else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr))
2588 NewAttr = S.mergeMinSizeAttr(D, *MA);
2589 else if (const auto *SNA = dyn_cast<SwiftNameAttr>(Attr))
2590 NewAttr = S.mergeSwiftNameAttr(D, *SNA, SNA->getName());
2591 else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr))
2592 NewAttr = S.mergeOptimizeNoneAttr(D, *OA);
2593 else if (const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(Attr))
2594 NewAttr = S.mergeInternalLinkageAttr(D, *InternalLinkageA);
2595 else if (const auto *CommonA = dyn_cast<CommonAttr>(Attr))
2596 NewAttr = S.mergeCommonAttr(D, *CommonA);
2597 else if (isa<AlignedAttr>(Attr))
2598 // AlignedAttrs are handled separately, because we need to handle all
2599 // such attributes on a declaration at the same time.
2600 NewAttr = nullptr;
2601 else if ((isa<DeprecatedAttr>(Attr) || isa<UnavailableAttr>(Attr)) &&
2602 (AMK == Sema::AMK_Override ||
2604 NewAttr = nullptr;
2605 else if (const auto *UA = dyn_cast<UuidAttr>(Attr))
2606 NewAttr = S.mergeUuidAttr(D, *UA, UA->getGuid(), UA->getGuidDecl());
2607 else if (const auto *SLHA = dyn_cast<SpeculativeLoadHardeningAttr>(Attr))
2608 NewAttr = S.mergeSpeculativeLoadHardeningAttr(D, *SLHA);
2609 else if (const auto *SLHA = dyn_cast<NoSpeculativeLoadHardeningAttr>(Attr))
2610 NewAttr = S.mergeNoSpeculativeLoadHardeningAttr(D, *SLHA);
2611 else if (const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(Attr))
2612 NewAttr = S.mergeImportModuleAttr(D, *IMA);
2613 else if (const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(Attr))
2614 NewAttr = S.mergeImportNameAttr(D, *INA);
2615 else if (const auto *TCBA = dyn_cast<EnforceTCBAttr>(Attr))
2616 NewAttr = S.mergeEnforceTCBAttr(D, *TCBA);
2617 else if (const auto *TCBLA = dyn_cast<EnforceTCBLeafAttr>(Attr))
2618 NewAttr = S.mergeEnforceTCBLeafAttr(D, *TCBLA);
2619 else if (Attr->shouldInheritEvenIfAlreadyPresent() || !DeclHasAttr(D, Attr))
2620 NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
2621
2622 if (NewAttr) {
2623 NewAttr->setInherited(true);
2624 D->addAttr(NewAttr);
2625 if (isa<MSInheritanceAttr>(NewAttr))
2626 S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
2627 return true;
2628 }
2629
2630 return false;
2631}
2632
2633static const NamedDecl *getDefinition(const Decl *D) {
2634 if (const TagDecl *TD = dyn_cast<TagDecl>(D))
2635 return TD->getDefinition();
2636 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2637 const VarDecl *Def = VD->getDefinition();
2638 if (Def)
2639 return Def;
2640 return VD->getActingDefinition();
2641 }
2642 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2643 const FunctionDecl *Def = nullptr;
2644 if (FD->isDefined(Def, true))
2645 return Def;
2646 }
2647 return nullptr;
2648}
2649
2650static bool hasAttribute(const Decl *D, attr::Kind Kind) {
2651 for (const auto *Attribute : D->attrs())
2652 if (Attribute->getKind() == Kind)
2653 return true;
2654 return false;
2655}
2656
2657/// checkNewAttributesAfterDef - If we already have a definition, check that
2658/// there are no new attributes in this declaration.
2659static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
2660 if (!New->hasAttrs())
2661 return;
2662
2663 const NamedDecl *Def = getDefinition(Old);
2664 if (!Def || Def == New)
2665 return;
2666
2667 AttrVec &NewAttributes = New->getAttrs();
2668 for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
2669 const Attr *NewAttribute = NewAttributes[I];
2670
2671 if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
2672 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {
2673 Sema::SkipBodyInfo SkipBody;
2674 S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def), &SkipBody);
2675
2676 // If we're skipping this definition, drop the "alias" attribute.
2677 if (SkipBody.ShouldSkip) {
2678 NewAttributes.erase(NewAttributes.begin() + I);
2679 --E;
2680 continue;
2681 }
2682 } else {
2683 VarDecl *VD = cast<VarDecl>(New);
2684 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2686 ? diag::err_alias_after_tentative
2687 : diag::err_redefinition;
2688 S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
2689 if (Diag == diag::err_redefinition)
2690 S.notePreviousDefinition(Def, VD->getLocation());
2691 else
2692 S.Diag(Def->getLocation(), diag::note_previous_definition);
2693 VD->setInvalidDecl();
2694 }
2695 ++I;
2696 continue;
2697 }
2698
2699 if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2700 // Tentative definitions are only interesting for the alias check above.
2701 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
2702 ++I;
2703 continue;
2704 }
2705 }
2706
2707 if (hasAttribute(Def, NewAttribute->getKind())) {
2708 ++I;
2709 continue; // regular attr merging will take care of validating this.
2710 }
2711
2712 if (isa<C11NoReturnAttr>(NewAttribute)) {
2713 // C's _Noreturn is allowed to be added to a function after it is defined.
2714 ++I;
2715 continue;
2716 } else if (isa<UuidAttr>(NewAttribute)) {
2717 // msvc will allow a subsequent definition to add an uuid to a class
2718 ++I;
2719 continue;
2720 } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2721 if (AA->isAlignas()) {
2722 // C++11 [dcl.align]p6:
2723 // if any declaration of an entity has an alignment-specifier,
2724 // every defining declaration of that entity shall specify an
2725 // equivalent alignment.
2726 // C11 6.7.5/7:
2727 // If the definition of an object does not have an alignment
2728 // specifier, any other declaration of that object shall also
2729 // have no alignment specifier.
2730 S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
2731 << AA;
2732 S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
2733 << AA;
2734 NewAttributes.erase(NewAttributes.begin() + I);
2735 --E;
2736 continue;
2737 }
2738 } else if (isa<LoaderUninitializedAttr>(NewAttribute)) {
2739 // If there is a C definition followed by a redeclaration with this
2740 // attribute then there are two different definitions. In C++, prefer the
2741 // standard diagnostics.
2742 if (!S.getLangOpts().CPlusPlus) {
2743 S.Diag(NewAttribute->getLocation(),
2744 diag::err_loader_uninitialized_redeclaration);
2745 S.Diag(Def->getLocation(), diag::note_previous_definition);
2746 NewAttributes.erase(NewAttributes.begin() + I);
2747 --E;
2748 continue;
2749 }
2750 } else if (isa<SelectAnyAttr>(NewAttribute) &&
2751 cast<VarDecl>(New)->isInline() &&
2752 !cast<VarDecl>(New)->isInlineSpecified()) {
2753 // Don't warn about applying selectany to implicitly inline variables.
2754 // Older compilers and language modes would require the use of selectany
2755 // to make such variables inline, and it would have no effect if we
2756 // honored it.
2757 ++I;
2758 continue;
2759 } else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
2760 // We allow to add OMP[Begin]DeclareVariantAttr to be added to
2761 // declarations after defintions.
2762 ++I;
2763 continue;
2764 }
2765
2766 S.Diag(NewAttribute->getLocation(),
2767 diag::warn_attribute_precede_definition);
2768 S.Diag(Def->getLocation(), diag::note_previous_definition);
2769 NewAttributes.erase(NewAttributes.begin() + I);
2770 --E;
2771 }
2772}
2773
2774static void diagnoseMissingConstinit(Sema &S, const VarDecl *InitDecl,
2775 const ConstInitAttr *CIAttr,
2776 bool AttrBeforeInit) {
2777 SourceLocation InsertLoc = InitDecl->getInnerLocStart();
2778
2779 // Figure out a good way to write this specifier on the old declaration.
2780 // FIXME: We should just use the spelling of CIAttr, but we don't preserve
2781 // enough of the attribute list spelling information to extract that without
2782 // heroics.
2783 std::string SuitableSpelling;
2784 if (S.getLangOpts().CPlusPlus20)
2785 SuitableSpelling = std::string(
2786 S.PP.getLastMacroWithSpelling(InsertLoc, {tok::kw_constinit}));
2787 if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11)
2788 SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling(
2789 InsertLoc, {tok::l_square, tok::l_square,
2790 S.PP.getIdentifierInfo("clang"), tok::coloncolon,
2791 S.PP.getIdentifierInfo("require_constant_initialization"),
2792 tok::r_square, tok::r_square}));
2793 if (SuitableSpelling.empty())
2794 SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling(
2795 InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
2796 S.PP.getIdentifierInfo("require_constant_initialization"),
2797 tok::r_paren, tok::r_paren}));
2798 if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus20)
2799 SuitableSpelling = "constinit";
2800 if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11)
2801 SuitableSpelling = "[[clang::require_constant_initialization]]";
2802 if (SuitableSpelling.empty())
2803 SuitableSpelling = "__attribute__((require_constant_initialization))";
2804 SuitableSpelling += " ";
2805
2806 if (AttrBeforeInit) {
2807 // extern constinit int a;
2808 // int a = 0; // error (missing 'constinit'), accepted as extension
2809 assert(CIAttr->isConstinit() && "should not diagnose this for attribute");
2810 S.Diag(InitDecl->getLocation(), diag::ext_constinit_missing)
2811 << InitDecl << FixItHint::CreateInsertion(InsertLoc, SuitableSpelling);
2812 S.Diag(CIAttr->getLocation(), diag::note_constinit_specified_here);
2813 } else {
2814 // int a = 0;
2815 // constinit extern int a; // error (missing 'constinit')
2816 S.Diag(CIAttr->getLocation(),
2817 CIAttr->isConstinit() ? diag::err_constinit_added_too_late
2818 : diag::warn_require_const_init_added_too_late)
2820 S.Diag(InitDecl->getLocation(), diag::note_constinit_missing_here)
2821 << CIAttr->isConstinit()
2822 << FixItHint::CreateInsertion(InsertLoc, SuitableSpelling);
2823 }
2824}
2825
2826/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
2829 if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) {
2830 UsedAttr *NewAttr = OldAttr->clone(Context);
2831 NewAttr->setInherited(true);
2832 New->addAttr(NewAttr);
2833 }
2834
2835 if (!Old->hasAttrs() && !New->hasAttrs())
2836 return;
2837
2838 // [dcl.constinit]p1:
2839 // If the [constinit] specifier is applied to any declaration of a
2840 // variable, it shall be applied to the initializing declaration.
2841 const auto *OldConstInit = Old->getAttr<ConstInitAttr>();
2842 const auto *NewConstInit = New->getAttr<ConstInitAttr>();
2843 if (bool(OldConstInit) != bool(NewConstInit)) {
2844 const auto *OldVD = cast<VarDecl>(Old);
2845 auto *NewVD = cast<VarDecl>(New);
2846
2847 // Find the initializing declaration. Note that we might not have linked
2848 // the new declaration into the redeclaration chain yet.
2849 const VarDecl *InitDecl = OldVD->getInitializingDeclaration();
2850 if (!InitDecl &&
2851 (NewVD->hasInit() || NewVD->isThisDeclarationADefinition()))
2852 InitDecl = NewVD;
2853
2854 if (InitDecl == NewVD) {
2855 // This is the initializing declaration. If it would inherit 'constinit',
2856 // that's ill-formed. (Note that we do not apply this to the attribute
2857 // form).
2858 if (OldConstInit && OldConstInit->isConstinit())
2859 diagnoseMissingConstinit(*this, NewVD, OldConstInit,
2860 /*AttrBeforeInit=*/true);
2861 } else if (NewConstInit) {
2862 // This is the first time we've been told that this declaration should
2863 // have a constant initializer. If we already saw the initializing
2864 // declaration, this is too late.
2865 if (InitDecl && InitDecl != NewVD) {
2866 diagnoseMissingConstinit(*this, InitDecl, NewConstInit,
2867 /*AttrBeforeInit=*/false);
2868 NewVD->dropAttr<ConstInitAttr>();
2869 }
2870 }
2871 }
2872
2873 // Attributes declared post-definition are currently ignored.
2874 checkNewAttributesAfterDef(*this, New, Old);
2875
2876 if (AsmLabelAttr *NewA = New->getAttr<AsmLabelAttr>()) {
2877 if (AsmLabelAttr *OldA = Old->getAttr<AsmLabelAttr>()) {
2878 if (!OldA->isEquivalent(NewA)) {
2879 // This redeclaration changes __asm__ label.
2880 Diag(New->getLocation(), diag::err_different_asm_label);
2881 Diag(OldA->getLocation(), diag::note_previous_declaration);
2882 }
2883 } else if (Old->isUsed()) {
2884 // This redeclaration adds an __asm__ label to a declaration that has
2885 // already been ODR-used.
2886 Diag(New->getLocation(), diag::err_late_asm_label_name)
2887 << isa<FunctionDecl>(Old) << New->getAttr<AsmLabelAttr>()->getRange();
2888 }
2889 }
2890
2891 // Re-declaration cannot add abi_tag's.
2892 if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) {
2893 if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) {
2894 for (const auto &NewTag : NewAbiTagAttr->tags()) {
2895 if (std::find(OldAbiTagAttr->tags_begin(), OldAbiTagAttr->tags_end(),
2896 NewTag) == OldAbiTagAttr->tags_end()) {
2897 Diag(NewAbiTagAttr->getLocation(),
2898 diag::err_new_abi_tag_on_redeclaration)
2899 << NewTag;
2900 Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
2901 }
2902 }
2903 } else {
2904 Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
2905 Diag(Old->getLocation(), diag::note_previous_declaration);
2906 }
2907 }
2908
2909 // This redeclaration adds a section attribute.
2910 if (New->hasAttr<SectionAttr>() && !Old->hasAttr<SectionAttr>()) {
2911 if (auto *VD = dyn_cast<VarDecl>(New)) {
2912 if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) {
2913 Diag(New->getLocation(), diag::warn_attribute_section_on_redeclaration);
2914 Diag(Old->getLocation(), diag::note_previous_declaration);
2915 }
2916 }
2917 }
2918
2919 // Redeclaration adds code-seg attribute.
2920 const auto *NewCSA = New->getAttr<CodeSegAttr>();
2921 if (NewCSA && !Old->hasAttr<CodeSegAttr>() &&
2922 !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
2923 Diag(New->getLocation(), diag::warn_mismatched_section)
2924 << 0 /*codeseg*/;
2925 Diag(Old->getLocation(), diag::note_previous_declaration);
2926 }
2927
2928 if (!Old->hasAttrs())
2929 return;
2930
2931 bool foundAny = New->hasAttrs();
2932
2933 // Ensure that any moving of objects within the allocated map is done before
2934 // we process them.
2935 if (!foundAny) New->setAttrs(AttrVec());
2936
2937 for (auto *I : Old->specific_attrs<InheritableAttr>()) {
2938 // Ignore deprecated/unavailable/availability attributes if requested.
2940 if (isa<DeprecatedAttr>(I) ||
2941 isa<UnavailableAttr>(I) ||
2942 isa<AvailabilityAttr>(I)) {
2943 switch (AMK) {
2944 case AMK_None:
2945 continue;
2946
2947 case AMK_Redeclaration:
2948 case AMK_Override:
2950 LocalAMK = AMK;
2951 break;
2952 }
2953 }
2954
2955 // Already handled.
2956 if (isa<UsedAttr>(I))
2957 continue;
2958
2959 if (mergeDeclAttribute(*this, New, I, LocalAMK))
2960 foundAny = true;
2961 }
2962
2963 if (mergeAlignedAttrs(*this, New, Old))
2964 foundAny = true;
2965
2966 if (!foundAny) New->dropAttrs();
2967}
2968
2969/// mergeParamDeclAttributes - Copy attributes from the old parameter
2970/// to the new one.
2972 const ParmVarDecl *oldDecl,
2973 Sema &S) {
2974 // C++11 [dcl.attr.depend]p2:
2975 // The first declaration of a function shall specify the
2976 // carries_dependency attribute for its declarator-id if any declaration
2977 // of the function specifies the carries_dependency attribute.
2978 const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>();
2979 if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {
2980 S.Diag(CDA->getLocation(),
2981 diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/;
2982 // Find the first declaration of the parameter.
2983 // FIXME: Should we build redeclaration chains for function parameters?
2984 const FunctionDecl *FirstFD =
2985 cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl();
2986 const ParmVarDecl *FirstVD =
2987 FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
2988 S.Diag(FirstVD->getLocation(),
2989 diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
2990 }
2991
2992 if (!oldDecl->hasAttrs())
2993 return;
2994
2995 bool foundAny = newDecl->hasAttrs();
2996
2997 // Ensure that any moving of objects within the allocated map is
2998 // done before we process them.
2999 if (!foundAny) newDecl->setAttrs(AttrVec());
3000
3001 for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
3002 if (!DeclHasAttr(newDecl, I)) {
3003 InheritableAttr *newAttr =
3005 newAttr->setInherited(true);
3006 newDecl->addAttr(newAttr);
3007 foundAny = true;
3008 }
3009 }
3010
3011 if (!foundAny) newDecl->dropAttrs();
3012}
3013
3014static void mergeParamDeclTypes(ParmVarDecl *NewParam,
3015 const ParmVarDecl *OldParam,
3016 Sema &S) {
3017 if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) {
3018 if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) {
3019 if (*Oldnullability != *Newnullability) {
3020 S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr)
3022 *Newnullability,
3024 != 0))
3026 *Oldnullability,
3028 != 0));
3029 S.Diag(OldParam->getLocation(), diag::note_previous_declaration);
3030 }
3031 } else {
3032 QualType NewT = NewParam->getType();
3033 NewT = S.Context.getAttributedType(
3035 NewT, NewT);
3036 NewParam->setType(NewT);
3037 }
3038 }
3039}
3040
3041namespace {
3042
3043/// Used in MergeFunctionDecl to keep track of function parameters in
3044/// C.
3045struct GNUCompatibleParamWarning {
3046 ParmVarDecl *OldParm;
3047 ParmVarDecl *NewParm;
3048 QualType PromotedType;
3049};
3050
3051} // end anonymous namespace
3052
3053// Determine whether the previous declaration was a definition, implicit
3054// declaration, or a declaration.
3055template <typename T>
3056static std::pair<diag::kind, SourceLocation>
3057getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {
3058 diag::kind PrevDiag;
3059 SourceLocation OldLocation = Old->getLocation();
3060 if (Old->isThisDeclarationADefinition())
3061 PrevDiag = diag::note_previous_definition;
3062 else if (Old->isImplicit()) {
3063 PrevDiag = diag::note_previous_implicit_declaration;
3064 if (OldLocation.isInvalid())
3065 OldLocation = New->getLocation();
3066 } else
3067 PrevDiag = diag::note_previous_declaration;
3068 return std::make_pair(PrevDiag, OldLocation);
3069}
3070
3071/// canRedefineFunction - checks if a function can be redefined. Currently,
3072/// only extern inline functions can be redefined, and even then only in
3073/// GNU89 mode.
3074static bool canRedefineFunction(const FunctionDecl *FD,
3075 const LangOptions& LangOpts) {
3076 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3077 !LangOpts.CPlusPlus &&
3078 FD->isInlineSpecified() &&
3079 FD->getStorageClass() == SC_Extern);
3080}
3081
3083 const AttributedType *AT = T->getAs<AttributedType>();
3084 while (AT && !AT->isCallingConv())
3085 AT = AT->getModifiedType()->getAs<AttributedType>();
3086 return AT;
3087}
3088
3089template <typename T>
3090static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) {
3091 const DeclContext *DC = Old->getDeclContext();
3092 if (DC->isRecord())
3093 return false;
3094
3095 LanguageLinkage OldLinkage = Old->getLanguageLinkage();
3096 if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
3097 return true;
3098 if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
3099 return true;
3100 return false;
3101}
3102
3103template<typename T> static bool isExternC(T *D) { return D->isExternC(); }
3104static bool isExternC(VarTemplateDecl *) { return false; }
3105
3106/// Check whether a redeclaration of an entity introduced by a
3107/// using-declaration is valid, given that we know it's not an overload
3108/// (nor a hidden tag declaration).
3109template<typename ExpectedDecl>
3111 ExpectedDecl *New) {
3112 // C++11 [basic.scope.declarative]p4:
3113 // Given a set of declarations in a single declarative region, each of
3114 // which specifies the same unqualified name,
3115 // -- they shall all refer to the same entity, or all refer to functions
3116 // and function templates; or
3117 // -- exactly one declaration shall declare a class name or enumeration
3118 // name that is not a typedef name and the other declarations shall all
3119 // refer to the same variable or enumerator, or all refer to functions
3120 // and function templates; in this case the class name or enumeration
3121 // name is hidden (3.3.10).
3122
3123 // C++11 [namespace.udecl]p14:
3124 // If a function declaration in namespace scope or block scope has the
3125 // same name and the same parameter-type-list as a function introduced
3126 // by a using-declaration, and the declarations do not declare the same
3127 // function, the program is ill-formed.
3128
3129 auto *Old = dyn_cast<ExpectedDecl>(OldS->getTargetDecl());
3130 if (Old &&
3131 !Old->getDeclContext()->getRedeclContext()->Equals(
3132 New->getDeclContext()->getRedeclContext()) &&
3133 !(isExternC(Old) && isExternC(New)))
3134 Old = nullptr;
3135
3136 if (!Old) {
3137 S.Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
3138 S.Diag(OldS->getTargetDecl()->getLocation(), diag::note_using_decl_target);
3139 S.Diag(OldS->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
3140 return true;
3141 }
3142 return false;
3143}
3144
3146 const FunctionDecl *B) {
3147 assert(A->getNumParams() == B->getNumParams());
3148
3149 auto AttrEq = [](const ParmVarDecl *A, const ParmVarDecl *B) {
3150 const auto *AttrA = A->getAttr<PassObjectSizeAttr>();
3151 const auto *AttrB = B->getAttr<PassObjectSizeAttr>();
3152 if (AttrA == AttrB)
3153 return true;
3154 return AttrA && AttrB && AttrA->getType() == AttrB->getType() &&
3155 AttrA->isDynamic() == AttrB->isDynamic();
3156 };
3157
3158 return std::equal(A->param_begin(), A->param_end(), B->param_begin(), AttrEq);
3159}
3160
3161/// If necessary, adjust the semantic declaration context for a qualified
3162/// declaration to name the correct inline namespace within the qualifier.
3164 DeclaratorDecl *OldD) {
3165 // The only case where we need to update the DeclContext is when
3166 // redeclaration lookup for a qualified name finds a declaration
3167 // in an inline namespace within the context named by the qualifier:
3168 //
3169 // inline namespace N { int f(); }
3170 // int ::f(); // Sema DC needs adjusting from :: to N::.
3171 //
3172 // For unqualified declarations, the semantic context *can* change
3173 // along the redeclaration chain (for local extern declarations,
3174 // extern "C" declarations, and friend declarations in particular).
3175 if (!NewD->getQualifier())
3176 return;
3177
3178 // NewD is probably already in the right context.
3179 auto *NamedDC = NewD->getDeclContext()->getRedeclContext();
3180 auto *SemaDC = OldD->getDeclContext()->getRedeclContext();
3181 if (NamedDC->Equals(SemaDC))
3182 return;
3183
3184 assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) ||
3185 NewD->isInvalidDecl() || OldD->isInvalidDecl()) &&
3186 "unexpected context for redeclaration");
3187
3188 auto *LexDC = NewD->getLexicalDeclContext();
3189 auto FixSemaDC = [=](NamedDecl *D) {
3190 if (!D)
3191 return;
3192 D->setDeclContext(SemaDC);
3193 D->setLexicalDeclContext(LexDC);
3194 };
3195
3196 FixSemaDC(NewD);
3197 if (auto *FD = dyn_cast<FunctionDecl>(NewD))
3198 FixSemaDC(FD->getDescribedFunctionTemplate());
3199 else if (auto *VD = dyn_cast<VarDecl>(NewD))
3200 FixSemaDC(VD->getDescribedVarTemplate());
3201}
3202
3203/// MergeFunctionDecl - We just parsed a function 'New' from
3204/// declarator D which has the same name and scope as a previous
3205/// declaration 'Old'. Figure out how to resolve this situation,
3206/// merging decls or emitting diagnostics as appropriate.
3207///
3208/// In C++, New and Old must be declarations that are not
3209/// overloaded. Use IsOverload to determine whether New and Old are
3210/// overloaded, and to select the Old declaration that New should be
3211/// merged with.
3212///
3213/// Returns true if there was an error, false otherwise.
3215 Scope *S, bool MergeTypeWithOld) {
3216 // Verify the old decl was also a function.
3217 FunctionDecl *Old = OldD->getAsFunction();
3218 if (!Old) {
3219 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
3220 if (New->getFriendObjectKind()) {
3221 Diag(New->getLocation(), diag::err_using_decl_friend);
3222 Diag(Shadow->getTargetDecl()->getLocation(),
3223 diag::note_using_decl_target);
3224 Diag(Shadow->getUsingDecl()->getLocation(),
3225 diag::note_using_decl) << 0;
3226 return true;
3227 }
3228
3229 // Check whether the two declarations might declare the same function.
3230 if (checkUsingShadowRedecl<FunctionDecl>(*this, Shadow, New))
3231 return true;
3232 OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
3233 } else {
3234 Diag(New->getLocation(), diag::err_redefinition_different_kind)
3235 << New->getDeclName();
3236 notePreviousDefinition(OldD, New->getLocation());
3237 return true;
3238 }
3239 }
3240
3241 // If the old declaration was found in an inline namespace and the new
3242 // declaration was qualified, update the DeclContext to match.
3244
3245 // If the old declaration is invalid, just give up here.
3246 if (Old->isInvalidDecl())
3247 return true;
3248
3249 // Disallow redeclaration of some builtins.
3250 if (!getASTContext().canBuiltinBeRedeclared(Old)) {
3251 Diag(New->getLocation(), diag::err_builtin_redeclare) << Old->getDeclName();
3252 Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
3253 << Old << Old->getType();
3254 return true;
3255 }
3256
3257 diag::kind PrevDiag;
3258 SourceLocation OldLocation;
3259 std::tie(PrevDiag, OldLocation) =
3261
3262 // Don't complain about this if we're in GNU89 mode and the old function
3263 // is an extern inline function.
3264 // Don't complain about specializations. They are not supposed to have
3265 // storage classes.
3266 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3267 New->getStorageClass() == SC_Static &&
3268 Old->hasExternalFormalLinkage() &&
3271 if (getLangOpts().MicrosoftExt) {
3272 Diag(New->getLocation(), diag::ext_static_non_static) << New;
3273 Diag(OldLocation, PrevDiag);
3274 } else {
3275 Diag(New->getLocation(), diag::err_static_non_static) << New;
3276 Diag(OldLocation, PrevDiag);
3277 return true;
3278 }
3279 }
3280
3281 if (New->hasAttr<InternalLinkageAttr>() &&
3282 !Old->hasAttr<InternalLinkageAttr>()) {
3283 Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
3284 << New->getDeclName();
3287 }
3288
3290 return true;
3291
3292 if (!getLangOpts().CPlusPlus) {
3293 bool OldOvl = Old->hasAttr<OverloadableAttr>();
3294 if (OldOvl != New->hasAttr<OverloadableAttr>() && !Old->isImplicit()) {
3295 Diag(New->getLocation(), diag::err_attribute_overloadable_mismatch)
3296 << New << OldOvl;
3297
3298 // Try our best to find a decl that actually has the overloadable
3299 // attribute for the note. In most cases (e.g. programs with only one
3300 // broken declaration/definition), this won't matter.
3301 //
3302 // FIXME: We could do this if we juggled some extra state in
3303 // OverloadableAttr, rather than just removing it.
3304 const Decl *DiagOld = Old;
3305 if (OldOvl) {
3306 auto OldIter = llvm::find_if(Old->redecls(), [](const Decl *D) {
3307 const auto *A = D->getAttr<OverloadableAttr>();
3308 return A && !A->isImplicit();
3309 });
3310 // If we've implicitly added *all* of the overloadable attrs to this
3311 // chain, emitting a "previous redecl" note is pointless.
3312 DiagOld = OldIter == Old->redecls_end() ? nullptr : *OldIter;
3313 }
3314
3315 if (DiagOld)
3316 Diag(DiagOld->getLocation(),
3317 diag::note_attribute_overloadable_prev_overload)
3318 << OldOvl;
3319
3320 if (OldOvl)
3322 else
3323 New->dropAttr<OverloadableAttr>();
3324 }
3325 }
3326
3327 // If a function is first declared with a calling convention, but is later
3328 // declared or defined without one, all following decls assume the calling
3329 // convention of the first.
3330 //
3331 // It's OK if a function is first declared without a calling convention,
3332 // but is later declared or defined with the default calling convention.
3333 //
3334 // To test if either decl has an explicit calling convention, we look for
3335 // AttributedType sugar nodes on the type as written. If they are missing or
3336 // were canonicalized away, we assume the calling convention was implicit.
3337 //
3338 // Note also that we DO NOT return at this point, because we still have
3339 // other tests to run.
3340 QualType OldQType = Context.getCanonicalType(Old->getType());
3341 QualType NewQType = Context.getCanonicalType(New->getType());
3342 const FunctionType *OldType = cast<FunctionType>(OldQType);
3343 const FunctionType *NewType = cast<FunctionType>(NewQType);
3344 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
3345 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
3346 bool RequiresAdjustment = false;
3347
3348 if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {
3350 const FunctionType *FT =
3351 First->getType().getCanonicalType()->castAs<FunctionType>();
3353 bool NewCCExplicit = getCallingConvAttributedType(New->getType());
3354 if (!NewCCExplicit) {
3355 // Inherit the CC from the previous declaration if it was specified
3356 // there but not here.
3357 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
3358 RequiresAdjustment = true;
3359 } else if (Old->getBuiltinID()) {
3360 // Builtin attribute isn't propagated to the new one yet at this point,
3361 // so we check if the old one is a builtin.
3362
3363 // Calling Conventions on a Builtin aren't really useful and setting a
3364 // default calling convention and cdecl'ing some builtin redeclarations is
3365 // common, so warn and ignore the calling convention on the redeclaration.
3366 Diag(New->getLocation(), diag::warn_cconv_unsupported)
3367 << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
3369 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
3370 RequiresAdjustment = true;
3371 } else {
3372 // Calling conventions aren't compatible, so complain.
3373 bool FirstCCExplicit = getCallingConvAttributedType(First->getType());
3374 Diag(New->getLocation(), diag::err_cconv_change)
3375 << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
3376 << !FirstCCExplicit
3377 << (!FirstCCExplicit ? "" :
3379
3380 // Put the note on the first decl, since it is the one that matters.
3381 Diag(First->getLocation(), diag::note_previous_declaration);
3382 return true;
3383 }
3384 }
3385
3386 // FIXME: diagnose the other way around?
3387 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
3388 NewTypeInfo = NewTypeInfo.withNoReturn(true);
3389 RequiresAdjustment = true;
3390 }
3391
3392 // Merge regparm attribute.
3393 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
3394 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
3395 if (NewTypeInfo.getHasRegParm()) {
3396 Diag(New->getLocation(), diag::err_regparm_mismatch)
3397 << NewType->getRegParmType()
3398 << OldType->getRegParmType();
3399 Diag(OldLocation, diag::note_previous_declaration);
3400 return true;
3401 }
3402
3403 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
3404 RequiresAdjustment = true;
3405 }
3406
3407 // Merge ns_returns_retained attribute.
3408 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
3409 if (NewTypeInfo.getProducesResult()) {
3410 Diag(New->getLocation(), diag::err_function_attribute_mismatch)
3411 << "'ns_returns_retained'";
3412 Diag(OldLocation, diag::note_previous_declaration);
3413 return true;
3414 }
3415
3416 NewTypeInfo = NewTypeInfo.withProducesResult(true);
3417 RequiresAdjustment = true;
3418 }
3419
3420 if (OldTypeInfo.getNoCallerSavedRegs() !=
3421 NewTypeInfo.getNoCallerSavedRegs()) {
3422 if (NewTypeInfo.getNoCallerSavedRegs()) {
3425 Diag(New->getLocation(), diag::err_function_attribute_mismatch) << Attr;
3426 Diag(OldLocation, diag::note_previous_declaration);
3427 return true;
3428 }
3429
3430 NewTypeInfo = NewTypeInfo.withNoCallerSavedRegs(true);
3431 RequiresAdjustment = true;
3432 }
3433
3434 if (RequiresAdjustment) {
3437 New->setType(QualType(AdjustedType, 0));
3438 NewQType = Context.getCanonicalType(New->getType());
3439 }
3440
3441 // If this redeclaration makes the function inline, we may need to add it to
3442 // UndefinedButUsed.
3443 if (!Old->isInlined() && New->isInlined() &&
3444 !New->hasAttr<GNUInlineAttr>() &&
3445 !getLangOpts().GNUInline &&
3446 Old->isUsed(false) &&
3447 !Old->isDefined() && !New->isThisDeclarationADefinition())
3448 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
3449 SourceLocation()));
3450
3451 // If this redeclaration makes it newly gnu_inline, we don't want to warn
3452 // about it.
3453 if (New->hasAttr<GNUInlineAttr>() &&
3454 Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
3455 UndefinedButUsed.erase(Old->getCanonicalDecl());
3456 }
3457
3458 // If pass_object_size params don't match up perfectly, this isn't a valid
3459 // redeclaration.
3460 if (Old->getNumParams() > 0 && Old->getNumParams() == New->getNumParams() &&
3462 Diag(New->getLocation(), diag::err_different_pass_object_size_params)
3463 << New->getDeclName();
3464 Diag(OldLocation, PrevDiag) << Old << Old->getType();
3465 return true;
3466 }
3467
3468 if (getLangOpts().CPlusPlus) {
3469 // C++1z [over.load]p2
3470 // Certain function declarations cannot be overloaded:
3471 // -- Function declarations that differ only in the return type,
3472 // the exception specification, or both cannot be overloaded.
3473
3474 // Check the exception specifications match. This may recompute the type of
3475 // both Old and New if it resolved exception specifications, so grab the
3476 // types again after this. Because this updates the type, we do this before
3477 // any of the other checks below, which may update the "de facto" NewQType
3478 // but do not necessarily update the type of New.
3479 if (CheckEquivalentExceptionSpec(Old, New))
3480 return true;
3481 OldQType = Context.getCanonicalType(Old->getType());
3482 NewQType = Context.getCanonicalType(New->getType());
3483
3484 // Go back to the type source info to compare the declared return types,
3485 // per C++1y [dcl.type.auto]p13:
3486 // Redeclarations or specializations of a function or function template
3487 // with a declared return type that uses a placeholder type shall also
3488 // use that placeholder, not a deduced type.
3489 QualType OldDeclaredReturnType = Old->getDeclaredReturnType();
3490 QualType NewDeclaredReturnType = New->getDeclaredReturnType();
3491 if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) &&
3492 canFullyTypeCheckRedeclaration(New, Old, NewDeclaredReturnType,
3493 OldDeclaredReturnType)) {
3494 QualType ResQT;
3495 if (NewDeclaredReturnType->isObjCObjectPointerType() &&
3496 OldDeclaredReturnType->isObjCObjectPointerType())
3497 // FIXME: This does the wrong thing for a deduced return type.
3498 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
3499 if (ResQT.isNull()) {
3500 if (New->isCXXClassMember() && New->isOutOfLine())
3501 Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type)
3502 << New << New->getReturnTypeSourceRange();
3503 else
3504 Diag(New->getLocation(), diag::err_ovl_diff_return_type)
3505 << New->getReturnTypeSourceRange();
3506 Diag(OldLocation, PrevDiag) << Old << Old->getType()
3507 << Old->getReturnTypeSourceRange();
3508 return true;
3509 }
3510 else
3511 NewQType = ResQT;
3512 }
3513
3514 QualType OldReturnType = OldType->getReturnType();
3515 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
3516 if (OldReturnType != NewReturnType) {
3517 // If this function has a deduced return type and has already been
3518 // defined, copy the deduced value from the old declaration.
3519 AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
3520 if (OldAT && OldAT->isDeduced()) {
3521 New->setType(
3522 SubstAutoType(New->getType(),
3524 : OldAT->getDeducedType()));
3525 NewQType = Context.getCanonicalType(
3526 SubstAutoType(NewQType,
3528 : OldAT->getDeducedType()));
3529 }
3530 }
3531
3532 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
3533 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
3534 if (OldMethod && NewMethod) {
3535 // Preserve triviality.
3536 NewMethod->setTrivial(OldMethod->isTrivial());
3537
3538 // MSVC allows explicit template specialization at class scope:
3539 // 2 CXXMethodDecls referring to the same function will be injected.
3540 // We don't want a redeclaration error.
3541 bool IsClassScopeExplicitSpecialization =
3542 OldMethod->isFunctionTemplateSpecialization() &&
3544 bool isFriend = NewMethod->getFriendObjectKind();
3545
3546 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
3547 !IsClassScopeExplicitSpecialization) {
3548 // -- Member function declarations with the same name and the
3549 // same parameter types cannot be overloaded if any of them
3550 // is a static member function declaration.
3551 if (OldMethod->isStatic() != NewMethod->isStatic()) {
3552 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
3553 Diag(OldLocation, PrevDiag) << Old << Old->getType();
3554 return true;
3555 }
3556
3557 // C++ [class.mem]p1:
3558 // [...] A member shall not be declared twice in the
3559 // member-specification, except that a nested class or member
3560 // class template can be declared and then later defined.
3561 if (!inTemplateInstantiation()) {
3562 unsigned NewDiag;
3563 if (isa<CXXConstructorDecl>(OldMethod))
3564 NewDiag = diag::err_constructor_redeclared;
3565 else if (isa<CXXDestructorDecl>(NewMethod))
3566 NewDiag = diag::err_destructor_redeclared;
3567 else if (isa<CXXConversionDecl>(NewMethod))
3568 NewDiag = diag::err_conv_function_redeclared;
3569 else
3570 NewDiag = diag::err_member_redeclared;
3571
3572 Diag(New->getLocation(), NewDiag);
3573 } else {
3574 Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
3575 << New << New->getType();
3576 }
3577 Diag(OldLocation, PrevDiag) << Old << Old->getType();
3578 return true;
3579
3580 // Complain if this is an explicit declaration of a special
3581 // member that was initially declared implicitly.
3582 //
3583 // As an exception, it's okay to befriend such methods in order
3584 // to permit the implicit constructor/destructor/operator calls.
3585 } else if (OldMethod->isImplicit()) {
3586 if (isFriend) {
3587 NewMethod->setImplicit();
3588 } else {
3589 Diag(NewMethod->getLocation(),
3590 diag::err_definition_of_implicitly_declared_member)
3591 << New << getSpecialMember(OldMethod);
3592 return true;
3593 }
3594 } else if (OldMethod->getFirstDecl()->isExplicitlyDefaulted() && !isFriend) {
3595 Diag(NewMethod->getLocation(),
3596 diag::err_definition_of_explicitly_defaulted_member)
3597 << getSpecialMember(OldMethod);
3598 return true;
3599 }
3600 }
3601
3602 // C++11 [dcl.attr.noreturn]p1:
3603 // The first declaration of a function shall specify the noreturn
3604 // attribute if any declaration of that function specifies the noreturn
3605 // attribute.
3606 const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>();
3607 if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) {
3608 Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl);
3609 Diag(Old->getFirstDecl()->getLocation(),
3610 diag::note_noreturn_missing_first_decl);
3611 }
3612
3613 // C++11 [dcl.attr.depend]p2:
3614 // The first declaration of a function shall specify the
3615 // carries_dependency attribute for its declarator-id if any declaration
3616 // of the function specifies the carries_dependency attribute.
3618 if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {
3619 Diag(CDA->getLocation(),
3620 diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/;
3621 Diag(Old->getFirstDecl()->getLocation(),
3622 diag::note_carries_dependency_missing_first_decl) << 0/*Function*/;
3623 }
3624
3625 // (C++98 8.3.5p3):
3626 // All declarations for a function shall agree exactly in both the
3627 // return type and the parameter-type-list.
3628 // We also want to respect all the extended bits except noreturn.
3629
3630 // noreturn should now match unless the old type info didn't have it.
3631 QualType OldQTypeForComparison = OldQType;
3632 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
3633 auto *OldType = OldQType->castAs<FunctionProtoType>();
3634 const FunctionType *OldTypeForComparison
3635 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
3636 OldQTypeForComparison = QualType(OldTypeForComparison, 0);
3637 assert(OldQTypeForComparison.isCanonical());
3638 }
3639
3640 if (haveIncompatibleLanguageLinkages(Old, New)) {
3641 // As a special case, retain the language linkage from previous
3642 // declarations of a friend function as an extension.
3643 //
3644 // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC
3645 // and is useful because there's otherwise no way to specify language
3646 // linkage within class scope.
3647 //
3648 // Check cautiously as the friend object kind isn't yet complete.
3649 if (New->getFriendObjectKind() != Decl::FOK_None) {
3650 Diag(New->getLocation(), diag::ext_retained_language_linkage) << New;
3651 Diag(OldLocation, PrevDiag);
3652 } else {
3653 Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3654 Diag(OldLocation, PrevDiag);
3655 return true;
3656 }
3657 }
3658
3659 // If the function types are compatible, merge the declarations. Ignore the
3660 // exception specifier because it was already checked above in
3661 // CheckEquivalentExceptionSpec, and we don't want follow-on diagnostics
3662 // about incompatible types under -fms-compatibility.
3663 if (Context.hasSameFunctionTypeIgnoringExceptionSpec(OldQTypeForComparison,
3664 NewQType))
3665 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3666
3667 // If the types are imprecise (due to dependent constructs in friends or
3668 // local extern declarations), it's OK if they differ. We'll check again
3669 // during instantiation.
3670 if (!canFullyTypeCheckRedeclaration(New, Old, NewQType, OldQType))
3671 return false;
3672
3673 // Fall through for conflicting redeclarations and redefinitions.
3674 }
3675
3676 // C: Function types need to be compatible, not identical. This handles
3677 // duplicate function decls like "void f(int); void f(enum X);" properly.
3678 if (!getLangOpts().CPlusPlus &&
3679 Context.typesAreCompatible(OldQType, NewQType)) {
3680 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
3681 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
3682 const FunctionProtoType *OldProto = nullptr;
3683 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
3684 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
3685 // The old declaration provided a function prototype, but the
3686 // new declaration does not. Merge in the prototype.
3687 assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
3688 SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
3689 NewQType =
3690 Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
3691 OldProto->getExtProtoInfo());
3692 New->setType(NewQType);
3694
3695 // Synthesize parameters with the same types.
3697 for (const auto &ParamType : OldProto->param_types()) {
3699 SourceLocation(), nullptr,
3700 ParamType, /*TInfo=*/nullptr,
3701 SC_None, nullptr);
3702 Param->setScopeInfo(0, Params.size());
3703 Param->setImplicit();
3704 Params.push_back(Param);
3705 }
3706
3707 New->setParams(Params);
3708 }
3709
3710 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3711 }
3712
3713 // Check if the function types are compatible when pointer size address
3714 // spaces are ignored.
3715 if (Context.hasSameFunctionTypeIgnoringPtrSizes(OldQType, NewQType))
3716 return false;
3717
3718 // GNU C permits a K&R definition to follow a prototype declaration
3719 // if the declared types of the parameters in the K&R definition
3720 // match the types in the prototype declaration, even when the
3721 // promoted types of the parameters from the K&R definition differ
3722 // from the types in the prototype. GCC then keeps the types from
3723 // the prototype.
3724 //
3725 // If a variadic prototype is followed by a non-variadic K&R definition,
3726 // the K&R definition becomes variadic. This is sort of an edge case, but
3727 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
3728 // C99 6.9.1p8.
3729 if (!getLangOpts().CPlusPlus &&
3730 Old->hasPrototype() && !New->hasPrototype() &&
3731 New->getType()->getAs<FunctionProtoType>() &&
3732 Old->getNumParams() == New->getNumParams()) {
3735 const FunctionProtoType *OldProto
3736 = Old->getType()->getAs<FunctionProtoType>();
3737 const FunctionProtoType *NewProto
3738 = New->getType()->getAs<FunctionProtoType>();
3739
3740 // Determine whether this is the GNU C extension.
3741 QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(),
3742 NewProto->getReturnType());
3743 bool LooseCompatible = !MergedReturn.isNull();
3744 for (unsigned Idx = 0, End = Old->getNumParams();
3745 LooseCompatible && Idx != End; ++Idx) {
3746 ParmVarDecl *OldParm = Old->getParamDecl(Idx);
3747 ParmVarDecl *NewParm = New->getParamDecl(Idx);
3748 if (Context.typesAreCompatible(OldParm->getType(),
3749 NewProto->getParamType(Idx))) {
3750 ArgTypes.push_back(NewParm->getType());
3751 } else if (Context.typesAreCompatible(OldParm->getType(),
3752 NewParm->getType(),
3753 /*CompareUnqualified=*/true)) {
3754 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
3755 NewProto->getParamType(Idx) };
3756 Warnings.push_back(Warn);
3757 ArgTypes.push_back(NewParm->getType());
3758 } else
3759 LooseCompatible = false;
3760 }
3761
3762 if (LooseCompatible) {
3763 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
3764 Diag(Warnings[Warn].NewParm->getLocation(),
3765 diag::ext_param_promoted_not_compatible_with_prototype)
3766 << Warnings[Warn].PromotedType
3767 << Warnings[Warn].OldParm->getType();
3768 if (Warnings[Warn].OldParm->getLocation().isValid())
3769 Diag(Warnings[Warn].OldParm->getLocation(),
3770 diag::note_previous_declaration);
3771 }
3772
3773 if (MergeTypeWithOld)
3774 New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
3775 OldProto->getExtProtoInfo()));
3776 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3777 }
3778
3779 // Fall through to diagnose conflicting types.
3780 }
3781
3782 // A function that has already been declared has been redeclared or
3783 // defined with a different type; show an appropriate diagnostic.
3784
3785 // If the previous declaration was an implicitly-generated builtin
3786 // declaration, then at the very least we should use a specialized note.
3787 unsigned BuiltinID;
3788 if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
3789 // If it's actually a library-defined builtin function like 'malloc'
3790 // or 'printf', just warn about the incompatible redeclaration.
3792 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
3793 Diag(OldLocation, diag::note_previous_builtin_declaration)
3794 << Old << Old->getType();
3795 return false;
3796 }
3797
3798 PrevDiag = diag::note_previous_builtin_declaration;
3799 }
3800
3801 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
3802 Diag(OldLocation, PrevDiag) << Old << Old->getType();
3803 return true;
3804}
3805
3806/// Completes the merge of two function declarations that are
3807/// known to be compatible.
3808///
3809/// This routine handles the merging of attributes and other
3810/// properties of function declarations from the old declaration to
3811/// the new declaration, once we know that New is in fact a
3812/// redeclaration of Old.
3813///
3814/// \returns false
3816 Scope *S, bool MergeTypeWithOld) {
3817 // Merge the attributes
3818 mergeDeclAttributes(New, Old);
3819
3820 // Merge "pure" flag.
3821 if (Old->isPure())
3822 New->setPure();
3823
3824 // Merge "used" flag.
3825 if (Old->getMostRecentDecl()->isUsed(false))
3826 New->setIsUsed();
3827
3828 // Merge attributes from the parameters. These can mismatch with K&R
3829 // declarations.
3830 if (New->getNumParams() == Old->getNumParams())
3831 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) {
3832 ParmVarDecl *NewParam = New->getParamDecl(i);
3833 ParmVarDecl *OldParam = Old->getParamDecl(i);
3834 mergeParamDeclAttributes(NewParam, OldParam, *this);
3835 mergeParamDeclTypes(NewParam, OldParam, *this);
3836 }
3837
3838 if (getLangOpts().CPlusPlus)
3839 return MergeCXXFunctionDecl(New, Old, S);
3840
3841 // Merge the function types so the we get the composite types for the return
3842 // and argument types. Per C11 6.2.7/4, only update the type if the old decl
3843 // was visible.
3844 QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
3845 if (!Merged.isNull() && MergeTypeWithOld)
3846 New->setType(Merged);
3847
3848 return false;
3849}
3850
3852 ObjCMethodDecl *oldMethod) {
3853 // Merge the attributes, including deprecated/unavailable
3854 AvailabilityMergeKind MergeKind =
3858 : AMK_Override;
3859
3860 mergeDeclAttributes(newMethod, oldMethod, MergeKind);
3861
3862 // Merge attributes from the parameters.
3864 oe = oldMethod->param_end();
3866 ni = newMethod->param_begin(), ne = newMethod->param_end();
3867 ni != ne && oi != oe; ++ni, ++oi)
3868 mergeParamDeclAttributes(*ni, *oi, *this);
3869
3870 CheckObjCMethodOverride(newMethod, oldMethod);
3871}
3872
3874 assert(!S.Context.hasSameType(New->getType(), Old->getType()));
3875
3877 ? diag::err_redefinition_different_type
3878 : diag::err_redeclaration_different_type)
3879 << New->getDeclName() << New->getType() << Old->getType();
3880
3881 diag::kind PrevDiag;
3882 SourceLocation OldLocation;
3883 std::tie(PrevDiag, OldLocation)
3885 S.Diag(OldLocation, PrevDiag);
3886 New->setInvalidDecl();
3887}
3888
3889/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
3890/// scope as a previous declaration 'Old'. Figure out how to merge their types,
3891/// emitting diagnostics as appropriate.
3892///
3893/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
3894/// to here in AddInitializerToDecl. We can't check them before the initializer
3895/// is attached.
3897 bool MergeTypeWithOld) {
3898 if (New->isInvalidDecl() || Old->isInvalidDecl())
3899 return;
3900
3901 QualType MergedT;
3902 if (getLangOpts().CPlusPlus) {
3903 if (New->getType()->isUndeducedType()) {
3904 // We don't know what the new type is until the initializer is attached.
3905 return;
3906 } else if (Context.hasSameType(New->getType(), Old->getType())) {
3907 // These could still be something that needs exception specs checked.
3908 return MergeVarDeclExceptionSpecs(New, Old);
3909 }
3910 // C++ [basic.link]p10:
3911 // [...] the types specified by all declarations referring to a given
3912 // object or function shall be identical, except that declarations for an
3913 // array object can specify array types that differ by the presence or
3914 // absence of a major array bound (8.3.4).
3915 else if (Old->getType()->isArrayType() && New->getType()->isArrayType()) {
3916 const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3917 const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3918
3919 // We are merging a variable declaration New into Old. If it has an array
3920 // bound, and that bound differs from Old's bound, we should diagnose the
3921 // mismatch.
3922 if (!NewArray->isIncompleteArrayType() && !NewArray->isDependentType()) {
3923 for (VarDecl *PrevVD = Old->getMostRecentDecl(); PrevVD;
3924 PrevVD = PrevVD->getPreviousDecl()) {
3925 QualType PrevVDTy = PrevVD->getType();
3926 if (PrevVDTy->isIncompleteArrayType() || PrevVDTy->isDependentType())
3927 continue;
3928
3929 if (!Context.hasSameType(New->getType(), PrevVDTy))
3930 return diagnoseVarDeclTypeMismatch(*this, New, PrevVD);
3931 }
3932 }
3933
3934 if (OldArray->isIncompleteArrayType() && NewArray->isArrayType()) {
3935 if (Context.hasSameType(OldArray->getElementType(),
3936 NewArray->getElementType()))
3937 MergedT = New->getType();
3938 }
3939 // FIXME: Check visibility. New is hidden but has a complete type. If New
3940 // has no array bound, it should not inherit one from Old, if Old is not
3941 // visible.
3942 else if (OldArray->isArrayType() && NewArray->isIncompleteArrayType()) {
3943 if (Context.hasSameType(OldArray->getElementType(),
3944 NewArray->getElementType()))
3945 MergedT = Old->getType();
3946 }
3947 }
3948 else if (New->getType()->isObjCObjectPointerType() &&
3949 Old->getType()->isObjCObjectPointerType()) {
3950 MergedT = Context.mergeObjCGCQualifiers(New->getType(),
3951 Old->getType());
3952 }
3953 } else {
3954 // C 6.2.7p2:
3955 // All declarations that refer to the same object or function shall have
3956 // compatible type.
3957 MergedT = Context.mergeTypes(New->getType(), Old->getType());
3958 }
3959 if (MergedT.isNull()) {
3960 // It's OK if we couldn't merge types if either type is dependent, for a
3961 // block-scope variable. In other cases (static data members of class
3962 // templates, variable templates, ...), we require the types to be
3963 // equivalent.
3964 // FIXME: The C++ standard doesn't say anything about this.
3965 if ((New->getType()->isDependentType() ||
3966 Old->getType()->isDependentType()) && New->isLocalVarDecl()) {
3967 // If the old type was dependent, we can't merge with it, so the new type
3968 // becomes dependent for now. We'll reproduce the original type when we
3969 // instantiate the TypeSourceInfo for the variable.
3970 if (!New->getType()->isDependentType() && MergeTypeWithOld)
3972 return;
3973 }
3974 return diagnoseVarDeclTypeMismatch(*this, New, Old);
3975 }
3976
3977 // Don't actually update the type on the new declaration if the old
3978 // declaration was an extern declaration in a different scope.
3979 if (MergeTypeWithOld)
3980 New->setType(MergedT);
3981}
3982
3983static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD,
3985 // C11 6.2.7p4:
3986 // For an identifier with internal or external linkage declared
3987 // in a scope in which a prior declaration of that identifier is
3988 // visible, if the prior declaration specifies internal or
3989 // external linkage, the type of the identifier at the later
3990 // declaration becomes the composite type.
3991 //
3992 // If the variable isn't visible, we do not merge with its type.
3993 if (Previous.isShadowed())
3994 return false;
3995
3996 if (S.getLangOpts().CPlusPlus) {
3997 // C++11 [dcl.array]p3:
3998 // If there is a preceding declaration of the entity in the same
3999 // scope in which the bound was specified, an omitted array bound
4000 // is taken to be the same as in that earlier declaration.
4001 return NewVD->isPreviousDeclInSameBlockScope() ||
4004 } else {
4005 // If the old declaration was function-local, don't merge with its
4006 // type unless we're in the same function.
4007 return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() ||
4008 OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext();
4009 }
4010}
4011
4012/// MergeVarDecl - We just parsed a variable 'New' which has the same name
4013/// and scope as a previous declaration 'Old'. Figure out how to resolve this
4014/// situation, merging decls or emitting diagnostics as appropriate.
4015///
4016/// Tentative definition rules (C99 6.9.2p2) are checked by
4017/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
4018/// definitions here, since the initializer hasn't been attached.
4019///
4021 // If the new decl is already invalid, don't do any other checking.
4022 if (New->isInvalidDecl())
4023 return;
4024
4025 if (!shouldLinkPossiblyHiddenDecl(Previous, New))
4026 return;
4027
4028 VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate();
4029
4030 // Verify the old decl was also a variable or variable template.
4031 VarDecl *Old = nullptr;
4032 VarTemplateDecl *OldTemplate = nullptr;
4033 if (Previous.isSingleResult()) {
4034 if (NewTemplate) {
4035 OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl());
4036 Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr;
4037
4038 if (auto *Shadow =
4039 dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
4040 if (checkUsingShadowRedecl<VarTemplateDecl>(*this, Shadow, NewTemplate))
4041 return New->setInvalidDecl();
4042 } else {
4043 Old = dyn_cast<VarDecl>(Previous.getFoundDecl());
4044
4045 if (auto *Shadow =
4046 dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
4047 if (checkUsingShadowRedecl<VarDecl>(*this, Shadow, New))
4048 return New->setInvalidDecl();
4049 }
4050 }
4051 if (!Old) {
4052 Diag(New->getLocation(), diag::err_redefinition_different_kind)
4053 << New->getDeclName();
4054 notePreviousDefinition(Previous.getRepresentativeDecl(),
4055 New->getLocation());
4056 return New->setInvalidDecl();
4057 }
4058
4059 // If the old declaration was found in an inline namespace and the new
4060 // declaration was qualified, update the DeclContext to match.
4062
4063 // Ensure the template parameters are compatible.
4064 if (NewTemplate &&
4066 OldTemplate->getTemplateParameters(),
4067 /*Complain=*/true, TPL_TemplateMatch))
4068 return New->setInvalidDecl();
4069
4070 // C++ [class.mem]p1:
4071 // A member shall not be declared twice in the member-specification [...]
4072 //
4073 // Here, we need only consider static data members.
4074 if (Old->isStaticDataMember() && !New->isOutOfLine()) {
4075 Diag(New->getLocation(), diag::err_duplicate_member)
4076 << New->getIdentifier();
4077 Diag(Old->getLocation(), diag::note_previous_declaration);
4078 New->setInvalidDecl();
4079 }
4080
4081 mergeDeclAttributes(New, Old);
4082 // Warn if an already-declared variable is made a weak_import in a subsequent
4083 // declaration
4084 if (New->hasAttr<WeakImportAttr>() &&
4085 Old->getStorageClass() == SC_None &&
4086 !Old->hasAttr<WeakImportAttr>()) {
4087 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
4089 // Remove weak_import attribute on new declaration.
4090 New->dropAttr<WeakImportAttr>();
4091 }
4092
4093 if (New->hasAttr<InternalLinkageAttr>() &&
4094 !Old->hasAttr<InternalLinkageAttr>()) {
4095 Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
4096 << New->getDeclName();
4099 }
4100
4101 // Merge the types.
4102 VarDecl *MostRecent = Old->getMostRecentDecl();
4103 if (MostRecent != Old) {
4104 MergeVarDeclTypes(New, MostRecent,
4105 mergeTypeWithPrevious(*this, New, MostRecent, Previous));
4106 if (New->isInvalidDecl())
4107 return;
4108 }
4109
4110 MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
4111 if (New->isInvalidDecl())
4112 return;
4113
4114 diag::kind PrevDiag;
4115 SourceLocation OldLocation;
4116 std::tie(PrevDiag, OldLocation) =
4118
4119 // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
4120 if (New->getStorageClass() == SC_Static &&
4121 !New->isStaticDataMember() &&
4122 Old->hasExternalFormalLinkage()) {
4123 if (getLangOpts().MicrosoftExt) {
4124 Diag(New->getLocation(), diag::ext_static_non_static)
4125 << New->getDeclName();
4126 Diag(OldLocation, PrevDiag);
4127 } else {
4128 Diag(New->getLocation(), diag::err_static_non_static)
4129 << New->getDeclName();
4130 Diag(OldLocation, PrevDiag);
4131 return New->setInvalidDecl();
4132 }
4133 }
4134 // C99 6.2.2p4:
4135 // For an identifier declared with the storage-class specifier
4136 // extern in a scope in which a prior declaration of that
4137 // identifier is visible,23) if the prior declaration specifies
4138 // internal or external linkage, the linkage of the identifier at
4139 // the later declaration is the same as the linkage specified at
4140 // the prior declaration. If no prior declaration is visible, or
4141 // if the prior declaration specifies no linkage, then the
4142 // identifier has external linkage.
4143 if (New->hasExternalStorage() && Old->hasLinkage())
4144 /* Okay */;
4145 else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
4146 !New->isStaticDataMember() &&
4148 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
4149 Diag(OldLocation, PrevDiag);
4150 return New->setInvalidDecl();
4151 }
4152
4153 // Check if extern is followed by non-extern and vice-versa.
4154 if (New->hasExternalStorage() &&
4155 !Old->hasLinkage() && Old->isLocalVarDeclOrParm()) {
4156 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
4157 Diag(OldLocation, PrevDiag);
4158 return New->setInvalidDecl();
4159 }
4160 if (Old->hasLinkage() && New->isLocalVarDeclOrParm() &&
4161 !New->hasExternalStorage()) {
4162 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
4163 Diag(OldLocation, PrevDiag);
4164 return New->setInvalidDecl();
4165 }
4166
4168 return;
4169
4170 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
4171
4172 // FIXME: The test for external storage here seems wrong? We still
4173 // need to check for mismatches.
4174 if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
4175 // Don't complain about out-of-line definitions of static members.
4176 !(Old->getLexicalDeclContext()->isRecord() &&
4177 !New->getLexicalDeclContext()->isRecord())) {
4178 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
4179 Diag(OldLocation, PrevDiag);
4180 return New->setInvalidDecl();
4181 }
4182
4183 if (New->isInline() && !Old->getMostRecentDecl()->isInline()) {
4184 if (VarDecl *Def = Old->getDefinition()) {
4185 // C++1z [dcl.fcn.spec]p4:
4186 // If the definition of a variable appears in a translation unit before
4187 // its first declaration as inline, the program is ill-formed.
4188 Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
4189 Diag(Def->getLocation(), diag::note_previous_definition);
4190 }
4191 }
4192
4193 // If this redeclaration makes the variable inline, we may need to add it to
4194 // UndefinedButUsed.
4195 if (!Old->isInline() && New->isInline() && Old->isUsed(false) &&
4197 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
4198 SourceLocation()));
4199
4200 if (New->getTLSKind() != Old->getTLSKind()) {
4201 if (!Old->getTLSKind()) {
4202 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
4203 Diag(OldLocation, PrevDiag);
4204 } else if (!New->getTLSKind()) {
4205 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
4206 Diag(OldLocation, PrevDiag);
4207 } else {
4208 // Do not allow redeclaration to change the variable between requiring
4209 // static and dynamic initialization.
4210 // FIXME: GCC allows this, but uses the TLS keyword on the first
4211 // declaration to determine the kind. Do we need to be compatible here?
4212 Diag(New->getLocation(), diag::err_thread_thread_different_kind)
4213 << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
4214 Diag(OldLocation, PrevDiag);
4215 }
4216 }
4217
4218 // C++ doesn't have tentative definitions, so go right ahead and check here.
4219 if (getLangOpts().CPlusPlus &&
4221 if (Old->isStaticDataMember() && Old->getCanonicalDecl()->isInline() &&
4222 Old->getCanonicalDecl()->isConstexpr()) {
4223 // This definition won't be a definition any more once it's been merged.
4224 Diag(New->getLocation(),
4225 diag::warn_deprecated_redundant_constexpr_static_def);
4226 } else if (VarDecl *Def = Old->getDefinition()) {
4227 if (checkVarDeclRedefinition(Def, New))
4228 return;
4229 }
4230 }
4231
4232 if (haveIncompatibleLanguageLinkages(Old, New)) {
4233 Diag(New->getLocation(), diag::err_different_language_linkage) << New;
4234 Diag(OldLocation, PrevDiag);
4235 New->setInvalidDecl();
4236 return;
4237 }
4238
4239 // Merge "used" flag.
4240 if (Old->getMostRecentDecl()->isUsed(false))
4241 New->setIsUsed();
4242
4243 // Keep a chain of previous declarations.
4244 New->setPreviousDecl(Old);
4245 if (NewTemplate)
4246 NewTemplate->setPreviousDecl(OldTemplate);
4247
4248 // Inherit access appropriately.
4249 New->setAccess(Old->getAccess());
4250 if (NewTemplate)
4251 NewTemplate->setAccess(New->getAccess());
4252
4253 if (Old->isInline())
4254 New->setImplicitlyInline();
4255}
4256
4258 SourceManager &SrcMgr = getSourceManager();
4259 auto FNewDecLoc = SrcMgr.getDecomposedLoc(New);
4260 auto FOldDecLoc = SrcMgr.getDecomposedLoc(Old->getLocation());
4261 auto *FNew = SrcMgr.getFileEntryForID(FNewDecLoc.first);
4262 auto *FOld = SrcMgr.getFileEntryForID(FOldDecLoc.first);
4263 auto &HSI = PP.getHeaderSearchInfo();
4264 StringRef HdrFilename =
4265 SrcMgr.getFilename(SrcMgr.getSpellingLoc(Old->getLocation()));
4266
4267 auto noteFromModuleOrInclude = [&](Module *Mod,
4268 SourceLocation IncLoc) -> bool {
4269 // Redefinition errors with modules are common with non modular mapped
4270 // headers, example: a non-modular header H in module A that also gets
4271 // included directly in a TU. Pointing twice to the same header/definition
4272 // is confusing, try to get better diagnostics when modules is on.
4273 if (IncLoc.isValid()) {
4274 if (Mod) {
4275 Diag(IncLoc, diag::note_redefinition_modules_same_file)
4276 << HdrFilename.str() << Mod->getFullModuleName();
4277 if (!Mod->DefinitionLoc.isInvalid())
4278 Diag(Mod->DefinitionLoc, diag::note_defined_here)
4279 << Mod->getFullModuleName();
4280 } else {
4281 Diag(IncLoc, diag::note_redefinition_include_same_file)
4282 << HdrFilename.str();
4283 }
4284 return true;
4285 }
4286
4287 return false;
4288 };
4289
4290 // Is it the same file and same offset? Provide more information on why
4291 // this leads to a redefinition error.
4292 if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) {
4293 SourceLocation OldIncLoc = SrcMgr.getIncludeLoc(FOldDecLoc.first);
4294 SourceLocation NewIncLoc = SrcMgr.getIncludeLoc(FNewDecLoc.first);
4295 bool EmittedDiag =
4296 noteFromModuleOrInclude(Old->getOwningModule(), OldIncLoc);
4297 EmittedDiag |= noteFromModuleOrInclude(getCurrentModule(), NewIncLoc);
4298
4299 // If the header has no guards, emit a note suggesting one.
4300 if (FOld && !HSI.isFileMultipleIncludeGuarded(FOld))
4301 Diag(Old->getLocation(), diag::note_use_ifdef_guards);
4302
4303 if (EmittedDiag)
4304 return;
4305 }
4306
4307 // Redefinition coming from different files or couldn't do better above.
4308 if (Old->getLocation().isValid())
4309 Diag(Old->getLocation(), diag::note_previous_definition);
4310}
4311
4312/// We've just determined that \p Old and \p New both appear to be definitions
4313/// of the same variable. Either diagnose or fix the problem.
4315 if (!hasVisibleDefinition(Old) &&
4316 (New->getFormalLinkage() == InternalLinkage ||
4317 New->isInline() ||
4318 New->getDescribedVarTemplate() ||
4321 // The previous definition is hidden, and multiple definitions are
4322 // permitted (in separate TUs). Demote this to a declaration.
4324
4325 // Make the canonical definition visible.
4326 if (auto *OldTD = Old->getDescribedVarTemplate())
4329 return false;
4330 } else {
4331 Diag(New->getLocation(), diag::err_redefinition) << New;
4333 New->setInvalidDecl();
4334 return true;
4335 }
4336}
4337
4338/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
4339/// no declarator (e.g. "struct foo;") is parsed.
4340Decl *
4342 RecordDecl *&AnonRecord) {
4343 return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg(), false,
4344 AnonRecord);
4345}
4346
4347// The MS ABI changed between VS2013 and VS2015 with regard to numbers used to
4348// disambiguate entities defined in different scopes.
4349// While the VS2015 ABI fixes potential miscompiles, it is also breaks
4350// compatibility.
4351// We will pick our mangling number depending on which version of MSVC is being
4352// targeted.
4353static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S) {
4355 ? S->getMSCurManglingNumber()
4356 : S->getMSLastManglingNumber();
4357}
4358
4359void Sema::handleTagNumbering(const TagDecl *Tag, Scope *TagScope) {
4360 if (!Context.getLangOpts().CPlusPlus)
4361 return;
4362
4363 if (isa<CXXRecordDecl>(Tag->getParent())) {
4364 // If this tag is the direct child of a class, number it if
4365 // it is anonymous.
4366 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
4367 return;
4369 Context.getManglingNumberContext(Tag->getParent());
4371 Tag, MCtx.getManglingNumber(
4372 Tag, getMSManglingNumber(getLangOpts(), TagScope)));
4373 return;
4374 }
4375
4376 // If this tag isn't a direct child of a class, number it if it is local.
4378 Decl *ManglingContextDecl;
4379 std::tie(MCtx, ManglingContextDecl) =
4380 getCurrentMangleNumberContext(Tag->getDeclContext());
4381 if (MCtx) {
4383 Tag, MCtx->getManglingNumber(
4384 Tag, getMSManglingNumber(getLangOpts(), TagScope)));
4385 }
4386}
4387
4388namespace {
4389struct NonCLikeKind {
4390 enum {
4391 None,
4392 BaseClass,
4393 DefaultMemberInit,
4394 Lambda,
4395 Friend,
4396 OtherMember,
4397 Invalid,
4398 } Kind = None;
4399 SourceRange Range;
4400
4401 explicit operator bool() { return Kind != None; }
4402};
4403}
4404
4405/// Determine whether a class is C-like, according to the rules of C++
4406/// [dcl.typedef] for anonymous classes with typedef names for linkage.
4407static NonCLikeKind getNonCLikeKindForAnonymousStruct(const CXXRecordDecl *RD) {
4408 if (RD->isInvalidDecl())
4409 return {NonCLikeKind::Invalid, {}};
4410
4411 // C++ [dcl.typedef]p9: [P1766R1]
4412 // An unnamed class with a typedef name for linkage purposes shall not
4413 //
4414 // -- have any base classes
4415 if (RD->getNumBases())
4416 return {NonCLikeKind::BaseClass,
4418 RD->bases_end()[-1].getEndLoc())};
4419 bool Invalid = false;
4420 for (Decl *D : RD->decls()) {
4421 // Don't complain about things we already diagnosed.
4422 if (D->isInvalidDecl()) {
4423 Invalid = true;
4424 continue;
4425 }
4426
4427 // -- have any [...] default member initializers
4428 if (auto *FD = dyn_cast<FieldDecl>(D)) {
4429 if (FD->hasInClassInitializer()) {
4430 auto *Init = FD->getInClassInitializer();
4431 return {NonCLikeKind::DefaultMemberInit,
4432 Init ? Init->getSourceRange() : D->getSourceRange()};
4433 }
4434 continue;
4435 }
4436
4437 // FIXME: We don't allow friend declarations. This violates the wording of
4438 // P1766, but not the intent.
4439 if (isa<FriendDecl>(D))
4440 return {NonCLikeKind::Friend, D->getSourceRange()};
4441
4442 // -- declare any members other than non-static data members, member
4443 // enumerations, or member classes,
4444 if (isa<StaticAssertDecl>(D) || isa<IndirectFieldDecl>(D) ||
4445 isa<EnumDecl>(D))
4446 continue;
4447 auto *MemberRD = dyn_cast<CXXRecordDecl>(D);
4448 if (!MemberRD) {
4449 if (D->isImplicit())
4450 continue;
4451 return {NonCLikeKind::OtherMember, D->getSourceRange()};
4452 }
4453
4454 // -- contain a lambda-expression,
4455 if (MemberRD->isLambda())
4456 return {NonCLikeKind::Lambda, MemberRD->getSourceRange()};
4457
4458 // and all member classes shall also satisfy these requirements
4459 // (recursively).
4460 if (MemberRD->isThisDeclarationADefinition()) {
4461 if (auto Kind = getNonCLikeKindForAnonymousStruct(MemberRD))
4462 return Kind;
4463 }
4464 }
4465
4466 return {Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}};
4467}
4468
4470 TypedefNameDecl *NewTD) {
4471 if (TagFromDeclSpec->isInvalidDecl())
4472 return;
4473
4474 // Do nothing if the tag already has a name for linkage purposes.
4475 if (TagFromDeclSpec->hasNameForLinkage())
4476 return;
4477
4478 // A well-formed anonymous tag must always be a TUK_Definition.
4479 assert(TagFromDeclSpec->isThisDeclarationADefinition());
4480
4481 // The type must match the tag exactly; no qualifiers allowed.
4483 Context.getTagDeclType(TagFromDeclSpec))) {
4484 if (getLangOpts().CPlusPlus)
4485 Context.addTypedefNameForUnnamedTagDecl(TagFromDeclSpec, NewTD);
4486 return;
4487 }
4488
4489 // C++ [dcl.typedef]p9: [P1766R1, applied as DR]
4490 // An unnamed class with a typedef name for linkage purposes shall [be
4491 // C-like].
4492 //
4493 // FIXME: Also diagnose if we've already computed the linkage. That ideally
4494 // shouldn't happen, but there are constructs that the language rule doesn't
4495 // disallow for which we can't reasonably avoid computing linkage early.
4496 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TagFromDeclSpec);
4497 NonCLikeKind NonCLike = RD ? getNonCLikeKindForAnonymousStruct(RD)
4498 : NonCLikeKind();
4499 bool ChangesLinkage = TagFromDeclSpec->hasLinkageBeenComputed();
4500 if (NonCLike || ChangesLinkage) {
4501 if (NonCLike.Kind == NonCLikeKind::Invalid)
4502 return;
4503
4504 unsigned DiagID = diag::ext_non_c_like_anon_struct_in_typedef;
4505 if (ChangesLinkage) {
4506 // If the linkage changes, we can't accept this as an extension.
4507 if (NonCLike.Kind == NonCLikeKind::None)
4508 DiagID = diag::err_typedef_changes_linkage;
4509 else
4510 DiagID = diag::err_non_c_like_anon_struct_in_typedef;
4511 }
4512
4513 SourceLocation FixitLoc =
4514 getLocForEndOfToken(TagFromDeclSpec->getInnerLocStart());
4515 llvm::SmallString<40> TextToInsert;
4516 TextToInsert += ' ';
4517 TextToInsert += NewTD->getIdentifier()->getName();
4518
4519 Diag(FixitLoc, DiagID)
4520 << isa<TypeAliasDecl>(NewTD)
4521 << FixItHint::CreateInsertion(FixitLoc, TextToInsert);
4522 if (NonCLike.Kind != NonCLikeKind::None) {
4523 Diag(NonCLike.Range.getBegin(), diag::note_non_c_like_anon_struct)
4524 << NonCLike.Kind - 1 << NonCLike.Range;
4525 }
4526 Diag(NewTD->getLocation(), diag::note_typedef_for_linkage_here)
4527 << NewTD << isa<TypeAliasDecl>(NewTD);
4528
4529 if (ChangesLinkage)
4530 return;
4531 }
4532
4533 // Otherwise, set this as the anon-decl typedef for the tag.
4534 TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
4535}
4536
4538 switch (T) {
4540 return 0;
4542 return 1;
4544 return 2;
4546 return 3;
4547 case DeclSpec::TST_enum:
4548 return 4;
4549 default:
4550 llvm_unreachable("unexpected type specifier");
4551 }
4552}
4553
4554/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
4555/// no declarator (e.g. "struct foo;") is parsed. It also accepts template
4556/// parameters to cope with template friend declarations.
4557Decl *
4559 MultiTemplateParamsArg TemplateParams,
4560 bool IsExplicitInstantiation,
4561 RecordDecl *&AnonRecord) {
4562 Decl *TagD = nullptr;
4563 TagDecl *Tag = nullptr;
4569 TagD = DS.getRepAsDecl();
4570
4571 if (!TagD) // We probably had an error
4572 return nullptr;
4573
4574 // Note that the above type specs guarantee that the
4575 // type rep is a Decl, whereas in many of the others
4576 // it's a Type.
4577 if (isa<TagDecl>(TagD))
4578 Tag = cast<TagDecl>(TagD);
4579 else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD))
4580 Tag = CTD->getTemplatedDecl();
4581 }
4582
4583 if (Tag) {
4584 handleTagNumbering(Tag, S);
4585 Tag->setFreeStanding();
4586 if (Tag->isInvalidDecl())
4587 return Tag;
4588 }
4589
4590 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
4591 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
4592 // or incomplete types shall not be restrict-qualified."
4593 if (TypeQuals & DeclSpec::TQ_restrict)
4595 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
4596 << DS.getSourceRange();
4597 }
4598
4599 if (DS.isInlineSpecified())
4600 Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
4601 << getLangOpts().CPlusPlus17;
4602
4603 if (DS.hasConstexprSpecifier()) {
4604 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
4605 // and definitions of functions and variables.
4606 // C++2a [dcl.constexpr]p1: The consteval specifier shall be applied only to
4607 // the declaration of a function or function template
4608 if (Tag)
4609 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
4611 << static_cast<int>(DS.getConstexprSpecifier());
4612 else
4613 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_wrong_decl_kind)
4614 << static_cast<int>(DS.getConstexprSpecifier());
4615 // Don't emit warnings after this error.
4616 return TagD;
4617 }
4618
4620
4621 if (DS.isFriendSpecified()) {
4622 // If we're dealing with a decl but not a TagDecl, assume that
4623 // whatever routines created it handled the friendship aspect.
4624 if (TagD && !Tag)
4625 return nullptr;
4626 return ActOnFriendTypeDecl(S, DS, TemplateParams);
4627 }
4628
4629 const CXXScopeSpec &SS = DS.getTypeSpecScope();
4630 bool IsExplicitSpecialization =
4631 !TemplateParams.empty() && TemplateParams.back()->size() == 0;
4632 if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
4633 !IsExplicitInstantiation && !IsExplicitSpecialization &&
4634 !isa<ClassTemplatePartialSpecializationDecl>(Tag)) {
4635 // Per C++ [dcl.type.elab]p1, a class declaration cannot have a
4636 // nested-name-specifier unless it is an explicit instantiation
4637 // or an explicit specialization.
4638 //
4639 // FIXME: We allow class template partial specializations here too, per the
4640 // obvious intent of DR1819.
4641 //
4642 // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either.
4643 Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
4645 return nullptr;
4646 }
4647
4648 // Track whether this decl-specifier declares anything.
4649 bool DeclaresAnything = true;
4650
4651 // Handle anonymous struct definitions.
4652 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
4653 if (!Record->getDeclName() && Record->isCompleteDefinition() &&
4655 if (getLangOpts().CPlusPlus ||
4656 Record->getDeclContext()->isRecord()) {
4657 // If CurContext is a DeclContext that can contain statements,
4658 // RecursiveASTVisitor won't visit the decls that
4659 // BuildAnonymousStructOrUnion() will put into CurContext.
4660 // Also store them here so that they can be part of the
4661 // DeclStmt that gets created in this case.
4662 // FIXME: Also return the IndirectFieldDecls created by
4663 // BuildAnonymousStructOr union, for the same reason?
4665 AnonRecord = Record;
4666 return BuildAnonymousStructOrUnion(S, DS, AS, Record,
4668 }
4669
4670 DeclaresAnything = false;
4671 }
4672 }
4673
4674 // C11 6.7.2.1p2:
4675 // A struct-declaration that does not declare an anonymous structure or
4676 // anonymous union shall contain a struct-declarator-list.
4677 //
4678 // This rule also existed in C89 and C99; the grammar for struct-declaration
4679 // did not permit a struct-declaration without a struct-declarator-list.
4682 // Check for Microsoft C extension: anonymous struct/union member.
4683 // Handle 2 kinds of anonymous struct/union:
4684 // struct STRUCT;
4685 // union UNION;
4686 // and
4687 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct.
4688 // UNION_TYPE; <- where UNION_TYPE is a typedef union.
4689 if ((Tag && Tag->getDeclName()) ||
4691 RecordDecl *Record = nullptr;
4692 if (Tag)
4693 Record = dyn_cast<RecordDecl>(Tag);
4694 else if (const RecordType *RT =
4696 Record = RT->getDecl();
4697 else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType())
4698 Record = UT->getDecl();
4699
4700 if (Record && getLangOpts().MicrosoftExt) {
4701 Diag(DS.getBeginLoc(), diag::ext_ms_anonymous_record)
4702 << Record->isUnion() << DS.getSourceRange();
4703 return BuildMicrosoftCAnonymousStruct(S, DS, Record);
4704 }
4705
4706 DeclaresAnything = false;
4707 }
4708 }
4709
4710 // Skip all the checks below if we have a type error.
4712 (TagD && TagD->isInvalidDecl()))
4713 return TagD;
4714
4715 if (getLangOpts().CPlusPlus &&
4717 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
4718 if (Enum->enumerator_begin() == Enum->enumerator_end() &&
4719 !Enum->getIdentifier() && !Enum->isInvalidDecl())
4720 DeclaresAnything = false;
4721
4722 if (!DS.isMissingDeclaratorOk()) {
4723 // Customize diagnostic for a typedef missing a name.
4725 Diag(DS.getBeginLoc(), diag::ext_typedef_without_a_name)
4726 << DS.getSourceRange();
4727 else
4728 DeclaresAnything = false;
4729 }
4730
4731 if (DS.isModulePrivateSpecified() &&
4732 Tag && Tag->getDeclContext()->isFunctionOrMethod())
4733 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
4734 << Tag->getTagKind()
4736
4738
4739 // C 6.7/2:
4740 // A declaration [...] shall declare at least a declarator [...], a tag,
4741 // or the members of an enumeration.
4742 // C++ [dcl.dcl]p3:
4743 // [If there are no declarators], and except for the declaration of an
4744 // unnamed bit-field, the decl-specifier-seq shall introduce one or more
4745 // names into the program, or shall redeclare a name introduced by a
4746 // previous declaration.
4747 if (!DeclaresAnything) {
4748 // In C, we allow this as a (popular) extension / bug. Don't bother
4749 // producing further diagnostics for redundant qualifiers after this.
4750 Diag(DS.getBeginLoc(), (IsExplicitInstantiation || !TemplateParams.empty())
4751 ? diag::err_no_declarators
4752 : diag::ext_no_declarators)
4753 << DS.getSourceRange();
4754 return TagD;
4755 }
4756
4757 // C++ [dcl.stc]p1:
4758 // If a storage-class-specifier appears in a decl-specifier-seq, [...] the
4759 // init-declarator-list of the declaration shall not be empty.
4760 // C++ [dcl.fct.spec]p1:
4761 // If a cv-qualifier appears in a decl-specifier-seq, the
4762 // init-declarator-list of the declaration shall not be empty.
4763 //
4764 // Spurious qualifiers here appear to be valid in C.
4765 unsigned DiagID = diag::warn_standalone_specifier;
4766 if (getLangOpts().CPlusPlus)
4767 DiagID = diag::ext_standalone_specifier;
4768
4769 // Note that a linkage-specification sets a storage class, but
4770 // 'extern "C" struct foo;' is actually valid and not theoretically
4771 // useless.
4772 if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
4773 if (SCS == DeclSpec::SCS_mutable)
4774 // Since mutable is not a viable storage class specifier in C, there is
4775 // no reason to treat it as an extension. Instead, diagnose as an error.
4776 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember);
4777 else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef)
4778 Diag(DS.getStorageClassSpecLoc(), DiagID)
4780 }
4781
4785 if (DS.getTypeQualifiers()) {
4787 Diag(DS.getConstSpecLoc(), DiagID) << "const";
4789 Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
4790 // Restrict is covered above.
4792 Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
4794 Diag(DS.getUnalignedSpecLoc(), DiagID) << "__unaligned";
4795 }
4796
4797 // Warn about ignored type attributes, for example:
4798 // __attribute__((aligned)) struct A;
4799 // Attributes should be placed after tag to apply to type declaration.
4800 if (!DS.getAttributes().empty()) {
4801 DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
4802 if (TypeSpecType == DeclSpec::TST_class ||
4803 TypeSpecType == DeclSpec::TST_struct ||
4804 TypeSpecType == DeclSpec::TST_interface ||
4805 TypeSpecType == DeclSpec::TST_union ||
4806 TypeSpecType == DeclSpec::TST_enum) {
4807 for (const ParsedAttr &AL : DS.getAttributes())
4808 Diag(AL.getLoc(), diag::warn_declspec_attribute_ignored)
4809 << AL << GetDiagnosticTypeSpecifierID(TypeSpecType);
4810 }
4811 }
4812
4813 return TagD;
4814}
4815
4816/// We are trying to inject an anonymous member into the given scope;
4817/// check if there's an existing declaration that can't be overloaded.
4818///
4819/// \return true if this is a forbidden redeclaration
4821 Scope *S,
4822 DeclContext *Owner,
4823 DeclarationName Name,
4824 SourceLocation NameLoc,
4825 bool IsUnion) {
4826 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
4828 if (!SemaRef.LookupName(R, S)) return false;
4829
4830 // Pick a representative declaration.
4832 assert(PrevDecl && "Expected a non-null Decl");
4833
4834 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
4835 return false;
4836
4837 SemaRef.Diag(NameLoc, diag::err_anonymous_record_member_redecl)
4838 << IsUnion << Name;
4839 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
4840
4841 return true;
4842}
4843
4844/// InjectAnonymousStructOrUnionMembers - Inject the members of the
4845/// anonymous struct or union AnonRecord into the owning context Owner
4846/// and scope S. This routine will be invoked just after we realize
4847/// that an unnamed union or struct is actually an anonymous union or
4848/// struct, e.g.,
4849///
4850/// @code
4851/// union {
4852/// int i;
4853/// float f;
4854/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
4855/// // f into the surrounding scope.x
4856/// @endcode
4857///
4858/// This routine is recursive, injecting the names of nested anonymous
4859/// structs/unions into the owning context and scope as well.
4860static bool
4862 RecordDecl *AnonRecord, AccessSpecifier AS,
4863 SmallVectorImpl<NamedDecl *> &Chaining) {
4864 bool Invalid = false;
4865
4866 // Look every FieldDecl and IndirectFieldDecl with a name.
4867 for (auto *D : AnonRecord->decls()) {
4868 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
4869 cast<NamedDecl>(D)->getDeclName()) {
4870 ValueDecl *VD = cast<ValueDecl>(D);
4871 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
4872 VD->getLocation(),
4873 AnonRecord->isUnion())) {
4874 // C++ [class.union]p2:
4875 // The names of the members of an anonymous union shall be
4876 // distinct from the names of any other entity in the
4877 // scope in which the anonymous union is declared.
4878 Invalid = true;
4879 } else {
4880 // C++ [class.union]p2:
4881 // For the purpose of name lookup, after the anonymous union
4882 // definition, the members of the anonymous union are
4883 // considered to have been defined in the scope in which the
4884 // anonymous union is declared.
4885 unsigned OldChainingSize = Chaining.size();
4886 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
4887 Chaining.append(IF->chain_begin(), IF->chain_end());
4888 else
4889 Chaining.push_back(VD);
4890
4891 assert(Chaining.size() >= 2);
4892 NamedDecl **NamedChain =
4893 new (SemaRef.Context)NamedDecl*[Chaining.size()];
4894 for (unsigned i = 0; i < Chaining.size(); i++)
4895 NamedChain[i] = Chaining[i];
4896
4898 SemaRef.Context, Owner, VD->getLocation(), VD->getIdentifier(),
4899 VD->getType(), {NamedChain, Chaining.size()});
4900
4901 for (const auto *Attr : VD->attrs())
4902 IndirectField->addAttr(Attr->clone(SemaRef.Context));
4903
4904 IndirectField->setAccess(AS);
4905 IndirectField->setImplicit();
4906 SemaRef.PushOnScopeChains(IndirectField, S);
4907
4908 // That includes picking up the appropriate access specifier.
4909 if (AS != AS_none) IndirectField->setAccess(AS);
4910
4911 Chaining.resize(OldChainingSize);
4912 }
4913 }
4914 }
4915
4916 return Invalid;
4917}
4918
4919/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
4920/// a VarDecl::StorageClass. Any error reporting is up to the caller:
4921/// illegal input values are mapped to SC_None.
4922static StorageClass
4924 DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
4925 assert(StorageClassSpec != DeclSpec::SCS_typedef &&
4926 "Parser allowed 'typedef' as storage class VarDecl.");
4927 switch (StorageClassSpec) {
4930 if (DS.isExternInLinkageSpec())
4931 return SC_None;
4932 return SC_Extern;
4933 case DeclSpec::SCS_static: return SC_Static;
4934 case DeclSpec::SCS_auto: return SC_Auto;
4937 // Illegal SCSs map to None: error reporting is up to the caller.
4938 case DeclSpec::SCS_mutable: // Fall through.
4939 case DeclSpec::SCS_typedef: return SC_None;
4940 }
4941 llvm_unreachable("unknown storage class specifier");
4942}
4943
4945 assert(Record->hasInClassInitializer());
4946
4947 for (const auto *I : Record->decls()) {
4948 const auto *FD = dyn_cast<FieldDecl>(I);
4949 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
4950 FD = IFD->getAnonField();
4951 if (FD && FD->hasInClassInitializer())
4952 return FD->getLocation();
4953 }
4954
4955 llvm_unreachable("couldn't find in-class initializer");
4956}
4957
4959 SourceLocation DefaultInitLoc) {
4960 if (!Parent->isUnion() || !Parent->hasInClassInitializer())
4961 return;
4962
4963 S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
4964 S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0;
4965}
4966
4968 CXXRecordDecl *AnonUnion) {
4969 if (!Parent->isUnion() || !Parent->hasInClassInitializer())
4970 return;
4971
4973}
4974
4975/// BuildAnonymousStructOrUnion - Handle the declaration of an
4976/// anonymous structure or union. Anonymous unions are a C++ feature
4977/// (C++ [class.union]) and a C11 feature; anonymous structures
4978/// are a C11 feature and GNU C++ extension.
4980 AccessSpecifier AS,
4981 RecordDecl *Record,
4982 const PrintingPolicy &Policy) {
4983 DeclContext *Owner = Record->getDeclContext();
4984
4985 // Diagnose whether this anonymous struct/union is an extension.
4986 if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
4987 Diag(Record->getLocation(), diag::ext_anonymous_union);
4988 else if (!Record->isUnion() && getLangOpts().CPlusPlus)
4989 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
4990 else if (!Record->isUnion() && !getLangOpts().C11)
4991 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
4992
4993 // C and C++ require different kinds of checks for anonymous
4994 // structs/unions.
4995 bool Invalid = false;
4996 if (getLangOpts().CPlusPlus) {
4997 const char *PrevSpec = nullptr;
4998 if (Record->isUnion()) {
4999 // C++ [class.union]p6:
5000 // C++17 [class.union.anon]p2:
5001 // Anonymous unions declared in a named namespace or in the
5002 // global namespace shall be declared static.
5003 unsigned DiagID;
5004 DeclContext *OwnerScope = Owner->getRedeclContext();
5006 (OwnerScope->isTranslationUnit() ||
5007 (OwnerScope->isNamespace() &&
5008 !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {
5009 Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
5010 << FixItHint::CreateInsertion(Record->getLocation(), "static ");
5011
5012 // Recover by adding 'static'.
5014 PrevSpec, DiagID, Policy);
5015 }
5016 // C++ [class.union]p6:
5017 // A storage class is not allowed in a declaration of an
5018 // anonymous union in a class scope.
5020 isa<RecordDecl>(Owner)) {
5022 diag::err_anonymous_union_with_storage_spec)
5024
5025 // Recover by removing the storage specifier.
5028 PrevSpec, DiagID, Context.getPrintingPolicy());
5029 }
5030 }
5031
5032 // Ignore const/volatile/restrict qualifiers.
5033 if (DS.getTypeQualifiers()) {
5035 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
5036 << Record->isUnion() << "const"
5040 diag::ext_anonymous_struct_union_qualified)
5041 << Record->isUnion() << "volatile"
5045 diag::ext_anonymous_struct_union_qualified)
5046 << Record->isUnion() << "restrict"
5050 diag::ext_anonymous_struct_union_qualified)
5051 << Record->isUnion() << "_Atomic"
5055 diag::ext_anonymous_struct_union_qualified)
5056 << Record->isUnion() << "__unaligned"
5058
5060 }
5061
5062 // C++ [class.union]p2:
5063 // The member-specification of an anonymous union shall only
5064 // define non-static data members. [Note: nested types and
5065 // functions cannot be declared within an anonymous union. ]
5066 for (auto *Mem : Record->decls()) {
5067 // Ignore invalid declarations; we already diagnosed them.
5068 if (Mem->isInvalidDecl())
5069 continue;
5070
5071 if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
5072 // C++ [class.union]p3:
5073 // An anonymous union shall not have private or protected
5074 // members (clause 11).
5075 assert(FD->getAccess() != AS_none);
5076 if (FD->getAccess() != AS_public) {
5077 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
5078 << Record->isUnion() << (FD->getAccess() == AS_protected);
5079 Invalid = true;
5080 }
5081
5082 // C++ [class.union]p1
5083 // An object of a class with a non-trivial constructor, a non-trivial
5084 // copy constructor, a non-trivial destructor, or a non-trivial copy
5085 // assignment operator cannot be a member of a union, nor can an
5086 // array of such objects.
5087 if (CheckNontrivialField(FD))
5088 Invalid = true;
5089 } else if (Mem->isImplicit()) {
5090 // Any implicit members are fine.
5091 } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {
5092 // This is a type that showed up in an
5093 // elaborated-type-specifier inside the anonymous struct or
5094 // union, but which actually declares a type outside of the
5095 // anonymous struct or union. It's okay.
5096 } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
5097 if (!MemRecord->isAnonymousStructOrUnion() &&
5098 MemRecord->getDeclName()) {
5099 // Visual C++ allows type definition in anonymous struct or union.
5100 if (getLangOpts().MicrosoftExt)
5101 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
5102 << Record->isUnion();
5103 else {
5104 // This is a nested type declaration.
5105 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
5106 << Record->isUnion();
5107 Invalid = true;
5108 }
5109 } else {
5110 // This is an anonymous type definition within another anonymous type.
5111 // This is a popular extension, provided by Plan9, MSVC and GCC, but
5112 // not part of standard C++.
5113 Diag(MemRecord->getLocation(),
5114 diag::ext_anonymous_record_with_anonymous_type)
5115 << Record->isUnion();
5116 }
5117 } else if (isa<AccessSpecDecl>(Mem)) {
5118 // Any access specifier is fine.
5119 } else if (isa<StaticAssertDecl>(Mem)) {
5120 // In C++1z, static_assert declarations are also fine.
5121 } else {
5122 // We have something that isn't a non-static data
5123 // member. Complain about it.
5124 unsigned DK = diag::err_anonymous_record_bad_member;
5125 if (isa<TypeDecl>(Mem))
5126 DK = diag::err_anonymous_record_with_type;
5127 else if (isa<FunctionDecl>(Mem))
5128 DK = diag::err_anonymous_record_with_function;
5129 else if (isa<VarDecl>(Mem))
5130 DK = diag::err_anonymous_record_with_static;
5131
5132 // Visual C++ allows type definition in anonymous struct or union.
5133 if (getLangOpts().MicrosoftExt &&
5134 DK == diag::err_anonymous_record_with_type)
5135 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
5136 << Record->isUnion();
5137 else {
5138 Diag(Mem->getLocation(), DK) << Record->isUnion();
5139 Invalid = true;
5140 }
5141 }
5142 }
5143
5144 // C++11 [class.union]p8 (DR1460):
5145 // At most one variant member of a union may have a
5146 // brace-or-equal-initializer.
5147 if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() &&
5148 Owner->isRecord())
5149 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner),
5150 cast<CXXRecordDecl>(Record));
5151 }
5152
5153 if (!Record->isUnion() && !Owner->isRecord()) {
5154 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
5155 << getLangOpts().CPlusPlus;
5156 Invalid = true;
5157 }
5158
5159 // C++ [dcl.dcl]p3:
5160 // [If there are no declarators], and except for the declaration of an
5161 // unnamed bit-field, the decl-specifier-seq shall introduce one or more
5162 // names into the program
5163 // C++ [class.mem]p2:
5164 // each such member-declaration shall either declare at least one member
5165 // name of the class or declare at least one unnamed bit-field
5166 //
5167 // For C this is an error even for a named struct, and is diagnosed elsewhere.
5168 if (getLangOpts().CPlusPlus && Record->field_empty())
5169 Diag(DS.getBeginLoc(), diag::ext_no_declarators) << DS.getSourceRange();
5170
5171 // Mock up a declarator.
5173 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
5174 assert(TInfo && "couldn't build declarator info for anonymous struct/union");
5175
5176 // Create a declaration for this anonymous struct/union.
5177 NamedDecl *Anon = nullptr;
5178 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
5179 Anon = FieldDecl::Create(
5180 Context, OwningClass, DS.getBeginLoc(), Record->getLocation(),
5181 /*IdentifierInfo=*/nullptr, Context.getTypeDeclType(Record), TInfo,
5182 /*BitWidth=*/nullptr, /*Mutable=*/false,
5183 /*InitStyle=*/ICIS_NoInit);
5184 Anon->setAccess(AS);
5185 ProcessDeclAttributes(S, Anon, Dc);
5186
5187 if (getLangOpts().CPlusPlus)
5188 FieldCollector->Add(cast<FieldDecl>(Anon));
5189 } else {
5190 DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
5192 if (SCSpec == DeclSpec::SCS_mutable) {
5193 // mutable can only appear on non-static class members, so it's always
5194 // an error here
5195 Diag(Record->getLocation(), diag::err_mutable_nonmember);
5196 Invalid = true;
5197 SC = SC_None;
5198 }
5199
5200 assert(DS.getAttributes().empty() && "No attribute expected");
5201 Anon = VarDecl::Create(Context, Owner, DS.getBeginLoc(),
5202 Record->getLocation(), /*IdentifierInfo=*/nullptr,
5203 Context.getTypeDeclType(Record), TInfo, SC);
5204
5205 // Default-initialize the implicit variable. This initialization will be
5206 // trivial in almost all cases, except if a union member has an in-class
5207 // initializer:
5208 // union { int n = 0; };
5210 }
5211 Anon->setImplicit();
5212
5213 // Mark this as an anonymous struct/union type.
5214 Record->setAnonymousStructOrUnion(true);
5215
5216 // Add the anonymous struct/union object to the current
5217 // context. We'll be referencing this object when we refer to one of
5218 // its members.
5219 Owner->addDecl(Anon);
5220
5221 // Inject the members of the anonymous struct/union into the owning
5222 // context and into the identifier resolver chain for name lookup
5223 // purposes.
5225 Chain.push_back(Anon);
5226
5227 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, Chain))
5228 Invalid = true;
5229
5230 if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
5231 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
5233 Decl *ManglingContextDecl;
5234 std::tie(MCtx, ManglingContextDecl) =
5235 getCurrentMangleNumberContext(NewVD->getDeclContext());
5236 if (MCtx) {
5238 NewVD, MCtx->getManglingNumber(
5239 NewVD, getMSManglingNumber(getLangOpts(), S)));
5241 }
5242 }
5243 }
5244
5245 if (Invalid)
5246 Anon->setInvalidDecl();
5247
5248 return Anon;
5249}
5250
5251/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
5252/// Microsoft C anonymous structure.
5253/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
5254/// Example:
5255///
5256/// struct A { int a; };
5257/// struct B { struct A; int b; };
5258///
5259/// void foo() {
5260/// B var;
5261/// var.a = 3;
5262/// }
5263///
5265 RecordDecl *Record) {
5266 assert(Record && "expected a record!");
5267
5268 // Mock up a declarator.
5270 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
5271 assert(TInfo && "couldn't build declarator info for anonymous struct");
5272
5273 auto *ParentDecl = cast<RecordDecl>(CurContext);
5274 QualType RecTy = Context.getTypeDeclType(Record);
5275
5276 // Create a declaration for this anonymous struct.
5277 NamedDecl *Anon =
5278 FieldDecl::Create(Context, ParentDecl, DS.getBeginLoc(), DS.getBeginLoc(),
5279 /*IdentifierInfo=*/nullptr, RecTy, TInfo,
5280 /*BitWidth=*/nullptr, /*Mutable=*/false,
5281 /*InitStyle=*/ICIS_NoInit);
5282 Anon->setImplicit();
5283
5284 // Add the anonymous struct object to the current context.
5285 CurContext->addDecl(Anon);
5286
5287 // Inject the members of the anonymous struct into the current
5288 // context and into the identifier resolver chain for name lookup
5289 // purposes.
5291 Chain.push_back(Anon);
5292
5293 RecordDecl *RecordDef = Record->getDefinition();
5294 if (RequireCompleteSizedType(Anon->getLocation(), RecTy,
5295 diag::err_field_incomplete_or_sizeless) ||
5297 AS_none, Chain)) {
5298 Anon->setInvalidDecl();
5299 ParentDecl->setInvalidDecl();
5300 }
5301
5302 return Anon;
5303}
5304
5305/// GetNameForDeclarator - Determine the full declaration name for the
5306/// given Declarator.
5310
5311/// Retrieves the declaration name from a parsed unqualified-id.
5314 DeclarationNameInfo NameInfo;
5315 NameInfo.setLoc(Name.StartLocation);
5316
5317 switch (Name.getKind()) {
5318
5321 NameInfo.setName(Name.Identifier);
5322 return NameInfo;
5323
5325 // C++ [temp.deduct.guide]p3:
5326 // The simple-template-id shall name a class template specialization.
5327 // The template-name shall be the same identifier as the template-name
5328 // of the simple-template-id.
5329 // These together intend to imply that the template-name shall name a
5330 // class template.
5331 // FIXME: template<typename T> struct X {};
5332 // template<typename T> using Y = X<T>;
5333 // Y(int) -> Y<int>;
5334 // satisfies these rules but does not name a class template.
5335 TemplateName TN = Name.TemplateName.get().get();
5336 auto *Template = TN.getAsTemplateDecl();
5337 if (!Template || !isa<ClassTemplateDecl>(Template)) {
5338 Diag(Name.StartLocation,
5339 diag::err_deduction_guide_name_not_class_template)
5341 if (Template)
5342 Diag(Template->getLocation(), diag::note_template_decl_here);
5343 return DeclarationNameInfo();
5344 }
5345
5346 NameInfo.setName(
5348 return NameInfo;
5349 }
5350
5353 Name.OperatorFunctionId.Operator));
5355 Name.OperatorFunctionId.SymbolLocations[0].getRawEncoding();
5357 = Name.EndLocation.getRawEncoding();
5358 return NameInfo;
5359
5362 Name.Identifier));
5363 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
5364 return NameInfo;
5365
5367 TypeSourceInfo *TInfo;
5368 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
5369 if (Ty.isNull())
5370 return DeclarationNameInfo();
5373 NameInfo.setNamedTypeInfo(TInfo);
5374 return NameInfo;
5375 }
5376
5378 TypeSourceInfo *TInfo;
5379 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
5380 if (Ty.isNull())
5381 return DeclarationNameInfo();
5384 NameInfo.setNamedTypeInfo(TInfo);
5385 return NameInfo;
5386 }
5387
5389 // In well-formed code, we can only have a constructor
5390 // template-id that refers to the current context, so go there
5391 // to find the actual type being constructed.
5392 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
5393 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
5394 return DeclarationNameInfo();
5395
5396 // Determine the type of the class being constructed.
5397 QualType CurClassType = Context.getTypeDeclType(CurClass);
5398
5399 // FIXME: Check two things: that the template-id names the same type as
5400 // CurClassType, and that the template-id does not occur when the name
5401 // was qualified.
5402
5404 Context.getCanonicalType(CurClassType)));
5405 // FIXME: should we retrieve TypeSourceInfo?
5406 NameInfo.setNamedTypeInfo(nullptr);
5407 return NameInfo;
5408 }
5409
5411 TypeSourceInfo *TInfo;
5412 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
5413 if (Ty.isNull())
5414 return DeclarationNameInfo();
5417 NameInfo.setNamedTypeInfo(TInfo);
5418 return NameInfo;
5419 }
5420
5422 TemplateName TName = Name.TemplateId->Template.get();
5423 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
5424 return Context.getNameForTemplate(TName, TNameLoc);
5425 }
5426
5427 } // switch (Name.getKind())
5428
5429 llvm_unreachable("Unknown name kind");
5430}
5431
5433 do {
5434 if (Ty->isPointerType() || Ty->isReferenceType())
5435 Ty = Ty->getPointeeType();
5436 else if (Ty->isArrayType())
5438 else
5439 return Ty.withoutLocalFastQualifiers();
5440 } while (true);
5441}
5442
5443/// hasSimilarParameters - Determine whether the C++ functions Declaration
5444/// and Definition have "nearly" matching parameters. This heuristic is
5445/// used to improve diagnostics in the case where an out-of-line function
5446/// definition doesn't match any declaration within the class or namespace.
5447/// Also sets Params to the list of indices to the parameters that differ
5448/// between the declaration and the definition. If hasSimilarParameters
5449/// returns true and Params is empty, then all of the parameters match.
5453 SmallVectorImpl<unsigned> &Params) {
5454 Params.clear();
5455 if (Declaration->param_size() != Definition->param_size())
5456 return false;
5457 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
5458 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
5459 QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
5460
5461 // The parameter types are identical
5462 if (Context.hasSameUnqualifiedType(DefParamTy, DeclParamTy))
5463 continue;
5464
5465 QualType DeclParamBaseTy = getCoreType(DeclParamTy);
5466 QualType DefParamBaseTy = getCoreType(DefParamTy);
5467 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
5468 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
5469
5470 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) ||
5471 (DeclTyName && DeclTyName == DefTyName))
5472 Params.push_back(Idx);
5473 else // The two parameters aren't even close
5474 return false;
5475 }
5476
5477 return true;
5478}
5479
5480/// NeedsRebuildingInCurrentInstantiation - Checks whether the given
5481/// declarator needs to be rebuilt in the current instantiation.
5482/// Any bits of declarator which appear before the name are valid for
5483/// consideration here. That's specifically the type in the decl spec
5484/// and the base type in any member-pointer chunks.
5486 DeclarationName Name) {
5487 // The types we specifically need to rebuild are:
5488 // - typenames, typeofs, and decltypes
5489 // - types which will become injected class names
5490 // Of course, we also need to rebuild any type referencing such a
5491 // type. It's safest to just say "dependent", but we call out a
5492 // few cases here.
5493
5494 DeclSpec &DS = D.getMutableDeclSpec();
5495 switch (DS.getTypeSpecType()) {
5499 case DeclSpec::TST_atomic: {
5500 // Grab the type from the parser.
5501 TypeSourceInfo *TSI = nullptr;
5502 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
5503 if (T.isNull() || !T->isInstantiationDependentType()) break;
5504
5505 // Make sure there's a type source info. This isn't really much
5506 // of a waste; most dependent types should have type source info
5507 // attached already.
5508 if (!TSI)
5510
5511 // Rebuild the type in the current instantiation.
5513 if (!TSI) return true;
5514
5515 // Store the new type back in the decl spec.
5516 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
5517 DS.UpdateTypeRep(LocType);
5518 break;
5519 }
5520
5523 Expr *E = DS.getRepAsExpr();
5525 if (Result.isInvalid()) return true;
5526 DS.UpdateExprRep(Result.get());
5527 break;
5528 }
5529
5530 default:
5531 // Nothing to do for these decl specs.
5532 break;
5533 }
5534
5535 // It doesn't matter what order we do this in.
5536 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
5537 DeclaratorChunk &Chunk = D.getTypeObject(I);
5538
5539 // The only type information in the declarator which can come
5540 // before the declaration name is the base type of a member
5541 // pointer.
5543 continue;
5544
5545 // Rebuild the scope specifier in-place.
5546 CXXScopeSpec &SS = Chunk.Mem.Scope();
5548 return true;
5549 }
5550
5551 return false;
5552}
5553
5567
5568/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
5569/// If T is the name of a class, then each of the following shall have a
5570/// name different from T:
5571/// - every static data member of class T;
5572/// - every member function of class T
5573/// - every member of class T that is itself a type;
5574/// \returns true if the declaration name violates these rules.
5576 DeclarationNameInfo NameInfo) {
5577 DeclarationName Name = NameInfo.getName();
5578
5579 CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC);
5580 while (Record && Record->isAnonymousStructOrUnion())
5581 Record = dyn_cast<CXXRecordDecl>(Record->getParent());
5582 if (Record && Record->getIdentifier() && Record->getDeclName() == Name) {
5583 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
5584 return true;
5585 }
5586
5587 return false;
5588}
5589
5590/// Diagnose a declaration whose declarator-id has the given
5591/// nested-name-specifier.
5592///
5593/// \param SS The nested-name-specifier of the declarator-id.
5594///
5595/// \param DC The declaration context to which the nested-name-specifier
5596/// resolves.
5597///
5598/// \param Name The name of the entity being declared.
5599///
5600/// \param Loc The location of the name of the entity being declared.
5601///
5602/// \param IsTemplateId Whether the name is a (simple-)template-id, and thus
5603/// we're declaring an explicit / partial specialization / instantiation.
5604///
5605/// \returns true if we cannot safely recover from this error, false otherwise.
5607 DeclarationName Name,
5608 SourceLocation Loc, bool IsTemplateId) {
5609 DeclContext *Cur = CurContext;
5610 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
5611 Cur = Cur->getParent();
5612
5613 // If the user provided a superfluous scope specifier that refers back to the
5614 // class in which the entity is already declared, diagnose and ignore it.
5615 //
5616 // class X {
5617 // void X::f();
5618 // };
5619 //
5620 // Note, it was once ill-formed to give redundant qualification in all
5621 // contexts, but that rule was removed by DR482.
5622 if (Cur->Equals(DC)) {
5623 if (Cur->isRecord()) {
5624 Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
5625 : diag::err_member_extra_qualification)
5626 << Name << FixItHint::CreateRemoval(SS.getRange());
5627 SS.clear();
5628 } else {
5629 Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
5630 }
5631 return false;
5632 }
5633
5634 // Check whether the qualifying scope encloses the scope of the original
5635 // declaration. For a template-id, we perform the checks in
5636 // CheckTemplateSpecializationScope.
5637 if (!Cur->Encloses(DC) && !IsTemplateId) {
5638 if (Cur->isRecord())
5639 Diag(Loc, diag::err_member_qualification)
5640 << Name << SS.getRange();
5641 else if (isa<TranslationUnitDecl>(DC))
5642 Diag(Loc, diag::err_invalid_declarator_global_scope)
5643 << Name << SS.getRange();
5644 else if (isa<FunctionDecl>(Cur))
5645 Diag(Loc, diag::err_invalid_declarator_in_function)
5646 << Name << SS.getRange();
5647 else if (isa<BlockDecl>(Cur))
5648 Diag(Loc, diag::err_invalid_declarator_in_block)
5649 << Name << SS.getRange();
5650 else
5651 Diag(Loc, diag::err_invalid_declarator_scope)
5652 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
5653
5654 return true;
5655 }
5656
5657 if (Cur->isRecord()) {
5658 // Cannot qualify members within a class.
5659 Diag(Loc, diag::err_member_qualification)
5660 << Name << SS.getRange();
5661 SS.clear();
5662
5663 // C++ constructors and destructors with incorrect scopes can break
5664 // our AST invariants by having the wrong underlying types. If
5665 // that's the case, then drop this declaration entirely.
5666 if ((Name.getNameKind() == DeclarationName::CXXConstructorName ||
5667 Name.getNameKind() == DeclarationName::CXXDestructorName) &&
5668 !Context.hasSameType(Name.getCXXNameType(),
5669 Context.getTypeDeclType(cast<CXXRecordDecl>(Cur))))
5670 return true;
5671
5672 return false;
5673 }
5674
5675 // C++11 [dcl.meaning]p1:
5676 // [...] "The nested-name-specifier of the qualified declarator-id shall
5677 // not begin with a decltype-specifer"
5679 while (SpecLoc.getPrefix())
5680 SpecLoc = SpecLoc.getPrefix();
5681 if (dyn_cast_or_null<DecltypeType>(
5682 SpecLoc.getNestedNameSpecifier()->getAsType()))
5683 Diag(Loc, diag::err_decltype_in_declarator)
5684 << SpecLoc.getTypeLoc().getSourceRange();
5685
5686 return false;
5687}
5688
5690 MultiTemplateParamsArg TemplateParamLists) {
5691 // TODO: consider using NameInfo for diagnostic.
5693 DeclarationName Name = NameInfo.getName();
5694
5695 // All of these full declarators require an identifier. If it doesn't have
5696 // one, the ParsedFreeStandingDeclSpec action should be used.
5697 if (D.isDecompositionDeclarator()) {
5698 return ActOnDecompositionDeclarator(S, D, TemplateParamLists);
5699 } else if (!Name) {
5700 if (!D.isInvalidType()) // Reject this if we think it is valid.
5701 Diag(D.getDeclSpec().getBeginLoc(), diag::err_declarator_need_ident)
5703 return nullptr;
5705 return nullptr;
5706
5707 // The scope passed in may not be a decl scope. Zip up the scope tree until
5708 // we find one that is.
5709 while ((S->getFlags() & Scope::DeclScope) == 0 ||
5710 (S->getFlags() & Scope::TemplateParamScope) != 0)
5711 S = S->getParent();
5712
5713 DeclContext *DC = CurContext;
5714 if (D.getCXXScopeSpec().isInvalid())
5715 D.setInvalidType();
5716 else if (D.getCXXScopeSpec().isSet()) {
5719 return nullptr;
5720
5721 bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
5722 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
5723 if (!DC || isa<EnumDecl>(DC)) {
5724 // If we could not compute the declaration context, it's because the
5725 // declaration context is dependent but does not refer to a class,
5726 // class template, or class template partial specialization. Complain
5727 // and return early, to avoid the coming semantic disaster.
5729 diag::err_template_qualified_declarator_no_match)
5731 << D.getCXXScopeSpec().getRange();
5732 return nullptr;
5733 }
5734 bool IsDependentContext = DC->isDependentContext();
5735
5736 if (!IsDependentContext &&
5738 return nullptr;
5739
5740 // If a class is incomplete, do not parse entities inside it.
5741 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
5743 diag::err_member_def_undefined_record)
5744 << Name << DC << D.getCXXScopeSpec().getRange();
5745 return nullptr;
5746 }
5747 if (!D.getDeclSpec().isFriendSpecified()) {
5749 D.getCXXScopeSpec(), DC, Name, D.getIdentifierLoc(),
5751 if (DC->isRecord())
5752 return nullptr;
5753
5754 D.setInvalidType();
5755 }
5756 }
5757
5758 // Check whether we need to rebuild the type of the given
5759 // declaration in the current instantiation.
5760 if (EnteringContext && IsDependentContext &&
5761 TemplateParamLists.size() != 0) {
5762 ContextRAII SavedContext(*this, DC);
5763 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
5764 D.setInvalidType();
5765 }
5766 }
5767
5768 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
5769 QualType R = TInfo->getType();
5770
5773 D.setInvalidType();
5774
5775 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
5777
5778 // See if this is a redefinition of a variable in the same scope.
5779 if (!D.getCXXScopeSpec().isSet()) {
5780 bool IsLinkageLookup = false;
5781 bool CreateBuiltins = false;
5782
5783 // If the declaration we're planning to build will be a function
5784 // or object with linkage, then look for another declaration with
5785 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
5786 //
5787 // If the declaration we're planning to build will be declared with
5788 // external linkage in the translation unit, create any builtin with
5789 // the same name.
5791 /* Do nothing*/;
5792 else if (CurContext->isFunctionOrMethod() &&
5794 R->isFunctionType())) {
5795 IsLinkageLookup = true;
5796 CreateBuiltins =
5800 CreateBuiltins = true;
5801
5802 if (IsLinkageLookup) {
5804 Previous.setRedeclarationKind(ForExternalRedeclaration);
5805 }
5806
5807 LookupName(Previous, S, CreateBuiltins);
5808 } else { // Something like "int foo::x;"
5810
5811 // C++ [dcl.meaning]p1:
5812 // When the declarator-id is qualified, the declaration shall refer to a
5813 // previously declared member of the class or namespace to which the
5814 // qualifier refers (or, in the case of a namespace, of an element of the
5815 // inline namespace set of that namespace (7.3.1)) or to a specialization
5816 // thereof; [...]
5817 //
5818 // Note that we already checked the context above, and that we do not have
5819 // enough information to make sure that Previous contains the declaration
5820 // we want to match. For example, given:
5821 //
5822 // class X {
5823 // void f();
5824 // void f(float);
5825 // };
5826 //
5827 // void X::f(int) { } // ill-formed
5828 //
5829 // In this case, Previous will point to the overload set
5830 // containing the two f's declared in X, but neither of them
5831 // matches.
5832
5833 // C++ [dcl.meaning]p1:
5834 // [...] the member shall not merely have been introduced by a
5835 // using-declaration in the scope of the class or namespace nominated by
5836 // the nested-name-specifier of the declarator-id.
5838 }
5839
5840 if (Previous.isSingleResult() &&
5841 Previous.getFoundDecl()->isTemplateParameter()) {
5842 // Maybe we will complain about the shadowed template parameter.
5843 if (!D.isInvalidType())
5845 Previous.getFoundDecl());
5846
5847 // Just pretend that we didn't see the previous declaration.
5848 Previous.clear();
5849 }
5850
5851 if (!R->isFunctionType() && DiagnoseClassNameShadow(DC, NameInfo))
5852 // Forget that the previous declaration is the injected-class-name.
5853 Previous.clear();
5854
5855 // In C++, the previous declaration we find might be a tag type
5856 // (class or enum). In this case, the new declaration will hide the
5857 // tag type. Note that this applies to functions, function templates, and
5858 // variables, but not to typedefs (C++ [dcl.typedef]p4) or variable templates.
5859 if (Previous.isSingleTagDecl() &&
5861 (TemplateParamLists.size() == 0 || R->isFunctionType()))
5862 Previous.clear();
5863
5864 // Check that there are no default arguments other than in the parameters
5865 // of a function declaration (C++ only).
5866 if (getLangOpts().CPlusPlus)
5868
5869 NamedDecl *New;
5870
5871 bool AddToScope = true;
5873 if (TemplateParamLists.size()) {
5874 Diag(D.getIdentifierLoc(), diag::err_template_typedef);
5875 return nullptr;
5876 }
5877
5878 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
5879 } else if (R->isFunctionType()) {
5880 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
5881 TemplateParamLists,
5882 AddToScope);
5883 } else {
5884 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists,
5885 AddToScope);
5886 }
5887
5888 if (!New)
5889 return nullptr;
5890
5891 // If this has an identifier and is not a function template specialization,
5892 // add it to the scope stack.
5893 if (New->getDeclName() && AddToScope)
5894 PushOnScopeChains(New, S);
5895
5898
5899 return New;
5900}
5901
5902/// Helper method to turn variable array types into constant array
5903/// types in certain situations which would otherwise be errors (for
5904/// GCC compatibility).
5906 ASTContext &Context,
5907 bool &SizeIsNegative,
5908 llvm::APSInt &Oversized) {
5909 // This method tries to turn a variable array into a constant
5910 // array even when the size isn't an ICE. This is necessary
5911 // for compatibility with code that depends on gcc's buggy
5912 // constant expression folding, like struct {char x[(int)(char*)2];}
5913 SizeIsNegative = false;
5914 Oversized = 0;
5915
5916 if (T->isDependentType())
5917 return QualType();
5918
5920 const Type *Ty = Qs.strip(T);
5921
5922 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
5923 QualType Pointee = PTy->getPointeeType();
5924 QualType FixedType =
5925 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
5926 Oversized);
5927 if (FixedType.isNull()) return FixedType;
5928 FixedType = Context.getPointerType(FixedType);
5929 return Qs.apply(Context, FixedType);
5930 }
5931 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
5932 QualType Inner = PTy->getInnerType();
5933 QualType FixedType =
5934 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
5935 Oversized);
5936 if (FixedType.isNull()) return FixedType;
5937 FixedType = Context.getParenType(FixedType);
5938 return Qs.apply(Context, FixedType);
5939 }
5940
5941 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
5942 if (!VLATy)
5943 return QualType();
5944
5945 QualType ElemTy = VLATy->getElementType();
5946 if (ElemTy->isVariablyModifiedType()) {
5947 ElemTy = TryToFixInvalidVariablyModifiedType(ElemTy, Context,
5948 SizeIsNegative, Oversized);
5949 if (ElemTy.isNull())
5950 return QualType();
5951 }
5952
5954 if (!VLATy->getSizeExpr() ||
5955 !VLATy->getSizeExpr()->EvaluateAsInt(Result, Context))
5956 return QualType();
5957
5958 llvm::APSInt Res = Result.Val.getInt();
5959
5960 // Check whether the array size is negative.
5961 if (Res.isSigned() && Res.isNegative()) {
5962 SizeIsNegative = true;
5963 return QualType();
5964 }
5965
5966 // Check whether the array is too large to be addressed.
5967 unsigned ActiveSizeBits =
5968 (!ElemTy->isDependentType() && !ElemTy->isVariablyModifiedType() &&
5969 !ElemTy->isIncompleteType() && !ElemTy->isUndeducedType())
5970 ? ConstantArrayType::getNumAddressingBits(Context, ElemTy, Res)
5971 : Res.getActiveBits();
5972 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
5973 Oversized = Res;
5974 return QualType();
5975 }
5976
5977 QualType FoldedArrayType = Context.getConstantArrayType(
5978 ElemTy, Res, VLATy->getSizeExpr(), ArrayType::Normal, 0);
5979 return Qs.apply(Context, FoldedArrayType);
5980}
5981
5982static void
5984 SrcTL = SrcTL.getUnqualifiedLoc();
5985 DstTL = DstTL.getUnqualifiedLoc();
5986 if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) {
5987 PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>();
5988 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(),
5989 DstPTL.getPointeeLoc());
5990 DstPTL.setStarLoc(SrcPTL.getStarLoc());
5991 return;
5992 }
5993 if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) {
5994 ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>();
5995 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(),
5996 DstPTL.getInnerLoc());
5997 DstPTL.setLParenLoc(SrcPTL.getLParenLoc());
5998 DstPTL.setRParenLoc(SrcPTL.getRParenLoc());
5999 return;
6000 }
6001 ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>();
6002 ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
6003 TypeLoc SrcElemTL = SrcATL.getElementLoc();
6004 TypeLoc DstElemTL = DstATL.getElementLoc();
6005 if (VariableArrayTypeLoc SrcElemATL =
6006 SrcElemTL.getAs<VariableArrayTypeLoc>()) {
6007 ConstantArrayTypeLoc DstElemATL = DstElemTL.castAs<ConstantArrayTypeLoc>();
6008 FixInvalidVariablyModifiedTypeLoc(SrcElemATL, DstElemATL);
6009 } else {
6010 DstElemTL.initializeFullCopy(SrcElemTL);
6011 }
6012 DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
6013 DstATL.setSizeExpr(SrcATL.getSizeExpr());
6014 DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
6015}
6016
6017/// Helper method to turn variable array types into constant array
6018/// types in certain situations which would otherwise be errors (for
6019/// GCC compatibility).
6020static TypeSourceInfo*
6022 ASTContext &Context,
6023 bool &SizeIsNegative,
6024 llvm::APSInt &Oversized) {
6025 QualType FixedTy
6026 = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context,
6027 SizeIsNegative, Oversized);
6028 if (FixedTy.isNull())
6029 return nullptr;
6030 TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy);
6032 FixedTInfo->getTypeLoc());
6033 return FixedTInfo;
6034}
6035
6036/// Attempt to fold a variable-sized type to a constant-sized type, returning
6037/// true if we were successful.
6039 QualType &T, SourceLocation Loc,
6040 unsigned FailedFoldDiagID) {
6041 bool SizeIsNegative;
6042 llvm::APSInt Oversized;
6044 TInfo, S.Context, SizeIsNegative, Oversized);
6045 if (FixedTInfo) {
6046 S.Diag(Loc, diag::ext_vla_folded_to_constant);
6047 TInfo = FixedTInfo;
6048 T = FixedTInfo->getType();
6049 return true;
6050 }
6051
6052 if (SizeIsNegative)
6053 S.Diag(Loc, diag::err_typecheck_negative_array_size);
6054 else if (Oversized.getBoolValue())
6055 S.Diag(Loc, diag::err_array_too_large) << Oversized.toString(10);
6056 else if (FailedFoldDiagID)
6057 S.Diag(Loc, FailedFoldDiagID);
6058 return false;
6059}
6060
6061/// Register the given locally-scoped extern "C" declaration so
6062/// that it can be found later for redeclarations. We include any extern "C"
6063/// declaration that is not visible in the translation unit here, not just
6064/// function-scope declarations.
6065void
6067 if (!getLangOpts().CPlusPlus &&
6069 // Don't need to track declarations in the TU in C.
6070 return;
6071
6072 // Note that we have a locally-scoped external with this name.
6074}
6075
6077 // FIXME: We can have multiple results via __attribute__((overloadable)).
6079 return Result.empty() ? nullptr : *Result.begin();
6080}
6081
6082/// Diagnose function specifiers on a declaration of an identifier that
6083/// does not identify a function.
6085 // FIXME: We should probably indicate the identifier in question to avoid
6086 // confusion for constructs like "virtual int a(), b;"
6087 if (DS.isVirtualSpecified())
6089 diag::err_virtual_non_function);
6090
6091 if (DS.hasExplicitSpecifier())
6093 diag::err_explicit_non_function);
6094
6095 if (DS.isNoreturnSpecified())
6097 diag::err_noreturn_non_function);
6098}
6099
6100NamedDecl*
6103 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
6104 if (D.getCXXScopeSpec().isSet()) {
6105 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
6106 << D.getCXXScopeSpec().getRange();
6107 D.setInvalidType();
6108 // Pretend we didn't see the scope specifier.
6109 DC = CurContext;
6110 Previous.clear();
6111 }
6112
6114
6116 Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
6117 << getLangOpts().CPlusPlus17;
6119 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
6120 << 1 << static_cast<int>(D.getDeclSpec().getConstexprSpecifier());
6121
6125 diag::err_deduction_guide_invalid_specifier)
6126 << "typedef";
6127 else
6128 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
6129 << D.getName().getSourceRange();
6130 return nullptr;
6131 }
6132
6133 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
6134 if (!NewTD) return nullptr;
6135
6136 // Handle attributes prior to checking for duplicates in MergeVarDecl
6137 ProcessDeclAttributes(S, NewTD, D);
6138
6140
6141 bool Redeclaration = D.isRedeclaration();
6142 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
6143 D.setRedeclaration(Redeclaration);
6144 return ND;
6145}
6146
6147void
6149 // C99 6.7.7p2: If a typedef name specifies a variably modified type
6150 // then it shall have block scope.
6151 // Note that variably modified types must be fixed before merging the decl so
6152 // that redeclarations will match.
6153 TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo();
6154 QualType T = TInfo->getType();
6155 if (T->isVariablyModifiedType()) {
6157
6158 if (S->getFnParent() == nullptr) {
6159 bool SizeIsNegative;
6160 llvm::APSInt Oversized;
6161 TypeSourceInfo *FixedTInfo =
6163 SizeIsNegative,
6164 Oversized);
6165 if (FixedTInfo) {
6166 Diag(NewTD->getLocation(), diag::ext_vla_folded_to_constant);
6167 NewTD->setTypeSourceInfo(FixedTInfo);
6168 } else {
6169 if (SizeIsNegative)
6170 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
6171 else if (T->isVariableArrayType())
6172 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
6173 else if (Oversized.getBoolValue())
6174 Diag(NewTD->getLocation(), diag::err_array_too_large)
6175 << Oversized.toString(10);
6176 else
6177 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
6178 NewTD->setInvalidDecl();
6179 }
6180 }
6181 }
6182}
6183
6184/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
6185/// declares a typedef-name, either using the 'typedef' type specifier or via
6186/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
6187NamedDecl*
6189 LookupResult &Previous, bool &Redeclaration) {
6190
6191 // Find the shadowed declaration before filtering for scope.
6192 NamedDecl *ShadowedDecl = getShadowedDeclaration(NewTD, Previous);
6193
6194 // Merge the decl with the existing one if appropriate. If the decl is
6195 // in an outer scope, it isn't the same thing.
6196 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false,
6197 /*AllowInlineNamespace*/false);
6199 if (!Previous.empty()) {
6200 Redeclaration = true;
6201 MergeTypedefNameDecl(S, NewTD, Previous);
6202 } else {
6204 }
6205
6206 if (ShadowedDecl && !Redeclaration)
6207 CheckShadow(NewTD, ShadowedDecl, Previous);
6208
6209 // If this is the C FILE type, notify the AST context.
6210 if (IdentifierInfo *II = NewTD->getIdentifier())
6211 if (!NewTD->isInvalidDecl() &&
6213 if (II->isStr("FILE"))
6214 Context.setFILEDecl(NewTD);
6215 else if (II->isStr("jmp_buf"))
6216 Context.setjmp_bufDecl(NewTD);
6217 else if (II->isStr("sigjmp_buf"))
6219 else if (II->isStr("ucontext_t"))
6221 }
6222
6223 return NewTD;
6224}
6225
6226/// Determines whether the given declaration is an out-of-scope
6227/// previous declaration.
6228///
6229/// This routine should be invoked when name lookup has found a
6230/// previous declaration (PrevDecl) that is not in the scope where a
6231/// new declaration by the same name is being introduced. If the new
6232/// declaration occurs in a local scope, previous declarations with
6233/// linkage may still be considered previous declarations (C99
6234/// 6.2.2p4-5, C++ [basic.link]p6).
6235///
6236/// \param PrevDecl the previous declaration found by name
6237/// lookup
6238///
6239/// \param DC the context in which the new declaration is being
6240/// declared.
6241///
6242/// \returns true if PrevDecl is an out-of-scope previous declaration
6243/// for a new delcaration with the same name.
6244static bool
6246 ASTContext &Context) {
6247 if (!PrevDecl)
6248 return false;
6249
6250 if (!PrevDecl->hasLinkage())
6251 return false;
6252
6253 if (Context.getLangOpts().CPlusPlus) {
6254 // C++ [basic.link]p6:
6255 // If there is a visible declaration of an entity with linkage
6256 // having the same name and type, ignoring entities declared
6257 // outside the innermost enclosing namespace scope, the block
6258 // scope declaration declares that same entity and receives the
6259 // linkage of the previous declaration.
6260 DeclContext *OuterContext = DC->getRedeclContext();
6261 if (!OuterContext->isFunctionOrMethod())
6262 // This rule only applies to block-scope declarations.
6263 return false;
6264
6265 DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
6266 if (PrevOuterContext->isRecord())
6267 // We found a member function: ignore it.
6268 return false;
6269
6270 // Find the innermost enclosing namespace for the new and
6271 // previous declarations.
6272 OuterContext = OuterContext->getEnclosingNamespaceContext();
6273 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
6274
6275 // The previous declaration is in a different namespace, so it
6276 // isn't the same function.
6277 if (!OuterContext->Equals(PrevOuterContext))
6278 return false;
6279 }
6280
6281 return true;
6282}
6283
6285 CXXScopeSpec &SS = D.getCXXScopeSpec();
6286 if (!SS.isSet()) return;
6288}
6289
6291 QualType type = decl->getType();
6292 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
6293 if (lifetime == Qualifiers::OCL_Autoreleasing) {
6294 // Various kinds of declaration aren't allowed to be __autoreleasing.
6295 unsigned kind = -1U;
6296 if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
6297 if (var->hasAttr<BlocksAttr>())
6298 kind = 0; // __block
6299 else if (!var->hasLocalStorage())
6300 kind = 1; // global
6301 } else if (isa<ObjCIvarDecl>(decl)) {
6302 kind = 3; // ivar
6303 } else if (isa<FieldDecl>(decl)) {
6304 kind = 2; // field
6305 }
6306
6307 if (kind != -1U) {
6308 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
6309 << kind;
6310 }
6311 } else if (lifetime == Qualifiers::OCL_None) {
6312 // Try to infer lifetime.
6313 if (!type->isObjCLifetimeType())
6314 return false;
6315
6316 lifetime = type->getObjCARCImplicitLifetime();
6317 type = Context.getLifetimeQualifiedType(type, lifetime);
6318 decl->setType(type);
6319 }
6320
6321 if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
6322 // Thread-local variables cannot have lifetime.
6323 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
6324 var->getTLSKind()) {
6325 Diag(var->getLocation(), diag::err_arc_thread_ownership)
6326 << var->getType();
6327 return true;
6328 }
6329 }
6330
6331 return false;
6332}
6333
6335 if (Decl->getType().hasAddressSpace())
6336 return;
6337 if (Decl->getType()->isDependentType())
6338 return;
6339 if (VarDecl *Var = dyn_cast<VarDecl>(Decl)) {
6340 QualType Type = Var->getType();
6341 if (Type->isSamplerT() || Type->isVoidType())
6342 return;
6344 if ((getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) &&
6345 Var->hasGlobalStorage())
6346 ImplAS = LangAS::opencl_global;
6347 // If the original type from a decayed type is an array type and that array
6348 // type has no address space yet, deduce it now.
6349 if (auto DT = dyn_cast<DecayedType>(Type)) {
6350 auto OrigTy = DT->getOriginalType();
6351 if (!OrigTy.hasAddressSpace() && OrigTy->isArrayType()) {
6352 // Add the address space to the original array type and then propagate
6353 // that to the element type through `getAsArrayType`.
6354 OrigTy = Context.getAddrSpaceQualType(OrigTy, ImplAS);
6355 OrigTy = QualType(Context.getAsArrayType(OrigTy), 0);
6356 // Re-generate the decayed type.
6357 Type = Context.getDecayedType(OrigTy);
6358 }
6359 }
6361 // Apply any qualifiers (including address space) from the array type to
6362 // the element type. This implements C99 6.7.3p8: "If the specification of
6363 // an array type includes any type qualifiers, the element type is so
6364 // qualified, not the array type."
6365 if (Type->isArrayType())
6367 Decl->setType(Type);
6368 }
6369}
6370
6372 // Ensure that an auto decl is deduced otherwise the checks below might cache
6373 // the wrong linkage.
6374 assert(S.ParsingInitForAutoVars.count(&ND) == 0);
6375
6376 // 'weak' only applies to declarations with external linkage.
6377 if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) {
6378 if (!ND.isExternallyVisible()) {
6379 S.Diag(Attr->getLocation(), diag::err_attribute_weak_static);
6380 ND.dropAttr<WeakAttr>();
6381 }
6382 }
6383 if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) {
6384 if (ND.isExternallyVisible()) {
6385 S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static);
6386 ND.dropAttr<WeakRefAttr>();
6387 ND.dropAttr<AliasAttr>();
6388 }
6389 }
6390
6391 if (auto *VD = dyn_cast<VarDecl>(&ND)) {
6392 if (VD->hasInit()) {
6393 if (const auto *Attr = VD->getAttr<AliasAttr>()) {
6394 assert(VD->isThisDeclarationADefinition() &&
6395 !VD->isExternallyVisible() && "Broken AliasAttr handled late!");
6396 S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD << 0;
6397 VD->dropAttr<AliasAttr>();
6398 }
6399 }
6400 }
6401
6402 // 'selectany' only applies to externally visible variable declarations.
6403 // It does not apply to functions.
6404 if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) {
6405 if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) {
6406 S.Diag(Attr->getLocation(),
6407 diag::err_attribute_selectany_non_extern_data);
6408 ND.dropAttr<SelectAnyAttr>();
6409 }
6410 }
6411
6412 if (const InheritableAttr *Attr = getDLLAttr(&ND)) {
6413 auto *VD = dyn_cast<VarDecl>(&ND);
6414 bool IsAnonymousNS = false;
6415 bool IsMicrosoft = S.Context.getTargetInfo().getCXXABI().isMicrosoft();
6416 if (VD) {
6417 const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(VD->getDeclContext());
6418 while (NS && !IsAnonymousNS) {
6419 IsAnonymousNS = NS->isAnonymousNamespace();
6420 NS = dyn_cast<NamespaceDecl>(NS->getParent());
6421 }
6422 }
6423 // dll attributes require external linkage. Static locals may have external
6424 // linkage but still cannot be explicitly imported or exported.
6425 // In Microsoft mode, a variable defined in anonymous namespace must have
6426 // external linkage in order to be exported.
6427 bool AnonNSInMicrosoftMode = IsAnonymousNS && IsMicrosoft;
6428 if ((ND.isExternallyVisible() && AnonNSInMicrosoftMode) ||
6429 (!AnonNSInMicrosoftMode &&
6430 (!ND.isExternallyVisible() || (VD && VD->isStaticLocal())))) {
6431 S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern)
6432 << &ND << Attr;
6433 ND.setInvalidDecl();
6434 }
6435 }
6436
6437 // Virtual functions cannot be marked as 'notail'.
6438 if (auto *Attr = ND.getAttr<NotTailCalledAttr>())
6439 if (auto *MD = dyn_cast<CXXMethodDecl>(&ND))
6440 if (MD->isVirtual()) {
6441 S.Diag(ND.getLocation(),
6442 diag::err_invalid_attribute_on_virtual_function)
6443 << Attr;
6445 }
6446
6447 // Check the attributes on the function type, if any.
6448 if (const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
6449 // Don't declare this variable in the second operand of the for-statement;
6450 // GCC miscompiles that by ending its lifetime before evaluating the
6451 // third operand. See gcc.gnu.org/PR86769.
6453 for (TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc();
6454 (ATL = TL.getAsAdjusted<AttributedTypeLoc>());
6455 TL = ATL.getModifiedLoc()) {
6456 // The [[lifetimebound]] attribute can be applied to the implicit object
6457 // parameter of a non-static member function (other than a ctor or dtor)
6458 // by applying it to the function type.
6459 if (const auto *A = ATL.getAttrAs<LifetimeBoundAttr>()) {
6460 const auto *MD = dyn_cast<CXXMethodDecl>(FD);
6461 if (!MD || MD->isStatic()) {
6462 S.Diag(A->getLocation(), diag::err_lifetimebound_no_object_param)
6463 << !MD << A->getRange();
6464 } else if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) {
6465 S.Diag(A->getLocation(), diag::err_lifetimebound_ctor_dtor)
6466 << isa<CXXDestructorDecl>(MD) << A->getRange();
6467 }
6468 }
6469 }
6470 }
6471}
6472
6474 NamedDecl *NewDecl,
6475 bool IsSpecialization,
6476 bool IsDefinition) {
6477 if (OldDecl->isInvalidDecl() || NewDecl->isInvalidDecl())
6478 return;
6479
6480 bool IsTemplate = false;
6481 if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) {
6482 OldDecl = OldTD->getTemplatedDecl();
6483 IsTemplate = true;
6484 if (!IsSpecialization)
6485 IsDefinition = false;
6486 }
6487 if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) {
6488 NewDecl = NewTD->getTemplatedDecl();
6489 IsTemplate = true;
6490 }
6491
6492 if (!OldDecl || !NewDecl)
6493 return;
6494
6495 const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>();
6496 const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>();
6497 const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>();
6498 const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>();
6499
6500 // dllimport and dllexport are inheritable attributes so we have to exclude
6501 // inherited attribute instances.
6502 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
6503 (NewExportAttr && !NewExportAttr->isInherited());
6504
6505 // A redeclaration is not allowed to add a dllimport or dllexport attribute,
6506 // the only exception being explicit specializations.
6507 // Implicitly generated declarations are also excluded for now because there
6508 // is no other way to switch these to use dllimport or dllexport.
6509 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
6510
6511 if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) {
6512 // Allow with a warning for free functions and global variables.
6513 bool JustWarn = false;
6514 if (!OldDecl->isCXXClassMember()) {
6515 auto *VD = dyn_cast<VarDecl>(OldDecl);
6516 if (VD && !VD->getDescribedVarTemplate())
6517 JustWarn = true;
6518 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
6519 if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
6520 JustWarn = true;
6521 }
6522
6523 // We cannot change a declaration that's been used because IR has already
6524 // been emitted. Dllimported functions will still work though (modulo
6525 // address equality) as they can use the thunk.
6526 if (OldDecl->isUsed())
6527 if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
6528 JustWarn = false;
6529
6530 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
6531 : diag::err_attribute_dll_redeclaration;
6532 S.Diag(NewDecl->getLocation(), DiagID)
6533 << NewDecl
6534 << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr);
6535 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
6536 if (!JustWarn) {
6537 NewDecl->setInvalidDecl();
6538 return;
6539 }
6540 }
6541
6542 // A redeclaration is not allowed to drop a dllimport attribute, the only
6543 // exceptions being inline function definitions (except for function
6544 // templates), local extern declarations, qualified friend declarations or
6545 // special MSVC extension: in the last case, the declaration is treated as if
6546 // it were marked dllexport.
6547 bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false;
6548 bool IsMicrosoftABI = S.Context.getTargetInfo().shouldDLLImportComdatSymbols();
6549 if (const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
6550 // Ignore static data because out-of-line definitions are diagnosed
6551 // separately.
6552 IsStaticDataMember = VD->isStaticDataMember();
6553 IsDefinition = VD->isThisDeclarationADefinition(S.Context) !=
6555 } else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
6556 IsInline = FD->isInlined();
6557 IsQualifiedFriend = FD->getQualifier() &&
6558 FD->getFriendObjectKind() == Decl::FOK_Declared;
6559 }
6560
6561 if (OldImportAttr && !HasNewAttr &&
6562 (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember &&
6563 !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {
6564 if (IsMicrosoftABI && IsDefinition) {
6565 S.Diag(NewDecl->getLocation(),
6566 diag::warn_redeclaration_without_import_attribute)
6567 << NewDecl;
6568 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
6569 NewDecl->dropAttr<DLLImportAttr>();
6570 NewDecl->addAttr(
6571 DLLExportAttr::CreateImplicit(S.Context, NewImportAttr->getRange()));
6572 } else {
6573 S.Diag(NewDecl->getLocation(),
6574 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
6575 << NewDecl << OldImportAttr;
6576 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
6577 S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
6578 OldDecl->dropAttr<DLLImportAttr>();
6579 NewDecl->dropAttr<DLLImportAttr>();
6580 }
6581 } else if (IsInline && OldImportAttr && !IsMicrosoftABI) {
6582 // In MinGW, seeing a function declared inline drops the dllimport
6583 // attribute.
6584 OldDecl->dropAttr<DLLImportAttr>();
6585 NewDecl->dropAttr<DLLImportAttr>();
6586 S.Diag(NewDecl->getLocation(),
6587 diag::warn_dllimport_dropped_from_inline_function)
6588 << NewDecl << OldImportAttr;
6589 }
6590
6591 // A specialization of a class template member function is processed here
6592 // since it's a redeclaration. If the parent class is dllexport, the
6593 // specialization inherits that attribute. This doesn't happen automatically
6594 // since the parent class isn't instantiated until later.
6595 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDecl)) {
6596 if (MD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization &&
6597 !NewImportAttr && !NewExportAttr) {
6598 if (const DLLExportAttr *ParentExportAttr =
6599 MD->getParent()->getAttr<DLLExportAttr>()) {
6600 DLLExportAttr *NewAttr = ParentExportAttr->clone(S.Context);
6601 NewAttr->setInherited(true);
6602 NewDecl->addAttr(NewAttr);
6603 }
6604 }
6605 }
6606}
6607
6608/// Given that we are within the definition of the given function,
6609/// will that definition behave like C99's 'inline', where the
6610/// definition is discarded except for optimization purposes?
6612 // Try to avoid calling GetGVALinkageForFunction.
6613
6614 // All cases of this require the 'inline' keyword.
6615 if (!FD->isInlined()) return false;
6616
6617 // This is only possible in C++ with the gnu_inline attribute.
6618 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
6619 return false;
6620
6621 // Okay, go ahead and call the relatively-more-expensive function.
6623}
6624
6625/// Determine whether a variable is extern "C" prior to attaching
6626/// an initializer. We can't just call isExternC() here, because that
6627/// will also compute and cache whether the declaration is externally
6628/// visible, which might change when we attach the initializer.
6629///
6630/// This can only be used if the declaration is known to not be a
6631/// redeclaration of an internal linkage declaration.
6632///
6633/// For instance:
6634///
6635/// auto x = []{};
6636///
6637/// Attaching the initializer here makes this declaration not externally
6638/// visible, because its type has internal linkage.
6639///
6640/// FIXME: This is a hack.
6641template<typename T>
6642static bool isIncompleteDeclExternC(Sema &S, const T *D) {
6643 if (S.getLangOpts().CPlusPlus) {
6644 // In C++, the overloadable attribute negates the effects of extern "C".
6645 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
6646 return false;
6647
6648 // So do CUDA's host/device attributes.
6649 if (S.getLangOpts().CUDA && (D->template hasAttr<CUDADeviceAttr>() ||
6650 D->template hasAttr<CUDAHostAttr>()))
6651 return false;
6652 }
6653 return D->isExternC();
6654}
6655
6656static bool shouldConsiderLinkage(const VarDecl *VD) {
6657 const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
6658 if (DC->isFunctionOrMethod() || isa<OMPDeclareReductionDecl>(DC) ||
6659 isa<OMPDeclareMapperDecl>(DC))
6660 return VD->hasExternalStorage();
6661 if (DC->isFileContext())
6662 return true;
6663 if (DC->isRecord())
6664 return false;
6665 if (isa<RequiresExprBodyDecl>(DC))
6666 return false;
6667 llvm_unreachable("Unexpected context");
6668}
6669
6670static bool shouldConsiderLinkage(const FunctionDecl *FD) {
6671 const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
6672 if (DC->isFileContext() || DC->isFunctionOrMethod() ||
6673 isa<OMPDeclareReductionDecl>(DC) || isa<OMPDeclareMapperDecl>(DC))
6674 return true;
6675 if (DC->isRecord())
6676 return false;
6677 llvm_unreachable("Unexpected context");
6678}
6679
6680static bool hasParsedAttr(Scope *S, const Declarator &PD,
6681 ParsedAttr::Kind Kind) {
6682 // Check decl attributes on the DeclSpec.
6683 if (PD.getDeclSpec().getAttributes().hasAttribute(Kind))
6684 return true;
6685
6686 // Walk the declarator structure, checking decl attributes that were in a type
6687 // position to the decl itself.
6688 for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) {
6689 if (PD.getTypeObject(I).getAttrs().hasAttribute(Kind))
6690 return true;
6691 }
6692
6693 // Finally, check attributes on the decl itself.
6694 return PD.getAttributes().hasAttribute(Kind);
6695}
6696
6697/// Adjust the \c DeclContext for a function or variable that might be a
6698/// function-local external declaration.
6700 if (!DC->isFunctionOrMethod())
6701 return false;
6702
6703 // If this is a local extern function or variable declared within a function
6704 // template, don't add it into the enclosing namespace scope until it is
6705 // instantiated; it might have a dependent type right now.
6706 if (DC->isDependentContext())
6707 return true;
6708
6709 // C++11 [basic.link]p7:
6710 // When a block scope declaration of an entity with linkage is not found to
6711 // refer to some other declaration, then that entity is a member of the
6712 // innermost enclosing namespace.
6713 //
6714 // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a
6715 // semantically-enclosing namespace, not a lexically-enclosing one.
6716 while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC))
6717 DC = DC->getParent();
6718 return true;
6719}
6720
6721/// Returns true if given declaration has external C language linkage.
6722static bool isDeclExternC(const Decl *D) {
6723 if (const auto *FD = dyn_cast<FunctionDecl>(D))
6724 return FD->isExternC();
6725 if (const auto *VD = dyn_cast<VarDecl>(D))
6726 return VD->isExternC();
6727
6728 llvm_unreachable("Unknown type of decl!");
6729}
6730/// Returns true if there hasn't been any invalid type diagnosed.
6732 DeclContext *DC, QualType R) {
6733 // OpenCL v2.0 s6.9.b - Image type can only be used as a function argument.
6734 // OpenCL v2.0 s6.13.16.1 - Pipe type can only be used as a function
6735 // argument.
6736 if (R->isImageType() || R->isPipeType()) {
6737 Se.Diag(D.getIdentifierLoc(),
6738 diag::err_opencl_type_can_only_be_used_as_function_parameter)
6739 << R;
6740 D.setInvalidType();
6741 return false;
6742 }
6743
6744 // OpenCL v1.2 s6.9.r:
6745 // The event type cannot be used to declare a program scope variable.
6746 // OpenCL v2.0 s6.9.q:
6747 // The clk_event_t and reserve_id_t types cannot be declared in program
6748 // scope.
6749 if (NULL == S->getParent()) {
6750 if (R->isReserveIDT() || R->isClkEventT() || R->isEventT()) {
6751 Se.Diag(D.getIdentifierLoc(),
6752 diag::err_invalid_type_for_program_scope_var)
6753 << R;
6754 D.setInvalidType();
6755 return false;
6756 }
6757 }
6758
6759 // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed.
6760 if (!Se.getOpenCLOptions().isEnabled("__cl_clang_function_pointers")) {
6761 QualType NR = R;
6762 while (NR->isPointerType() || NR->isMemberFunctionPointerType()) {
6764 Se.Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer);
6765 D.setInvalidType();
6766 return false;
6767 }
6768 NR = NR->getPointeeType();
6769 }
6770 }
6771
6772 if (!Se.getOpenCLOptions().isEnabled("cl_khr_fp16")) {
6773 // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and
6774 // half array type (unless the cl_khr_fp16 extension is enabled).
6775 if (Se.Context.getBaseElementType(R)->isHalfType()) {
6776 Se.Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R;
6777 D.setInvalidType();
6778 return false;
6779 }
6780 }
6781
6782 // OpenCL v1.2 s6.9.r:
6783 // The event type cannot be used with the __local, __constant and __global
6784 // address space qualifiers.
6785 if (R->isEventT()) {
6787 Se.Diag(D.getBeginLoc(), diag::err_event_t_addr_space_qual);
6788 D.setInvalidType();
6789 return false;
6790 }
6791 }
6792
6793 // C++ for OpenCL does not allow the thread_local storage qualifier.
6794 // OpenCL C does not support thread_local either, and
6795 // also reject all other thread storage class specifiers.
6797 if (TSC != TSCS_unspecified) {
6798 bool IsCXX = Se.getLangOpts().OpenCLCPlusPlus;
6800 diag::err_opencl_unknown_type_specifier)
6801 << IsCXX << Se.getLangOpts().getOpenCLVersionTuple().getAsString()
6802 << DeclSpec::getSpecifierName(TSC) << 1;
6803 D.setInvalidType();
6804 return false;
6805 }
6806
6807 if (R->isSamplerT()) {
6808 // OpenCL v1.2 s6.9.b p4:
6809 // The sampler type cannot be used with the __local and __global address
6810 // space qualifiers.
6813 Se.Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace);
6814 D.setInvalidType();
6815 }
6816
6817 // OpenCL v1.2 s6.12.14.1:
6818 // A global sampler must be declared with either the constant address
6819 // space qualifier or with the const qualifier.
6820 if (DC->isTranslationUnit() &&
6822 R.isConstQualified())) {
6823 Se.Diag(D.getIdentifierLoc(), diag::err_opencl_nonconst_global_sampler);
6824 D.setInvalidType();
6825 }
6826 if (D.isInvalidType())
6827 return false;
6828 }
6829 return true;
6830}
6831
6833 Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo,
6834 LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists,
6835 bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {
6836 QualType R = TInfo->getType();
6838
6839 IdentifierInfo *II = Name.getAsIdentifierInfo();
6840
6841 if (D.isDecompositionDeclarator()) {
6842 // Take the name of the first declarator as our name for diagnostic
6843 // purposes.
6844 auto &Decomp = D.getDecompositionDeclarator();
6845 if (!Decomp.bindings().empty()) {
6846 II = Decomp.bindings()[0].Name;
6847 Name = II;
6848 }
6849 } else if (!II) {
6850 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) << Name;
6851 return nullptr;
6852 }
6853
6854
6857
6858 // dllimport globals without explicit storage class are treated as extern. We
6859 // have to change the storage class this early to get the right DeclContext.
6860 if (SC == SC_None && !DC->isRecord() &&
6861 hasParsedAttr(S, D, ParsedAttr::AT_DLLImport) &&
6862 !hasParsedAttr(S, D, ParsedAttr::AT_DLLExport))
6863 SC = SC_Extern;
6864
6865 DeclContext *OriginalDC = DC;
6866 bool IsLocalExternDecl = SC == SC_Extern &&
6868
6869 if (SCSpec == DeclSpec::SCS_mutable) {
6870 // mutable can only appear on non-static class members, so it's always
6871 // an error here
6872 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
6873 D.setInvalidType();
6874 SC = SC_None;
6875 }
6876
6877 if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register &&
6878 !D.getAsmLabel() && !getSourceManager().isInSystemMacro(
6880 // In C++11, the 'register' storage class specifier is deprecated.
6881 // Suppress the warning in system macros, it's used in macros in some
6882 // popular C system headers, such as in glibc's htonl() macro.
6884 getLangOpts().CPlusPlus17 ? diag::ext_register_storage_class
6885 : diag::warn_deprecated_register)
6887 }
6888
6890
6891 if (!DC->isRecord() && S->getFnParent() == nullptr) {
6892 // C99 6.9p2: The storage-class specifiers auto and register shall not
6893 // appear in the declaration specifiers in an external declaration.
6894 // Global Register+Asm is a GNU extension we support.
6895 if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) {
6896 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
6897 D.setInvalidType();
6898 }
6899 }
6900
6901 // If this variable has a variable-modified type and an initializer, try to
6902 // fold to a constant-sized type. This is otherwise invalid.
6903 if (D.hasInitializer() && R->isVariablyModifiedType())
6905 /*DiagID=*/0);
6906
6907 bool IsMemberSpecialization = false;
6908 bool IsVariableTemplateSpecialization = false;
6909 bool IsPartialSpecialization = false;
6910 bool IsVariableTemplate = false;
6911 VarDecl *NewVD = nullptr;
6912 VarTemplateDecl *NewTemplate = nullptr;
6913 TemplateParameterList *TemplateParams = nullptr;
6914 if (!getLangOpts().CPlusPlus) {
6916 II, R, TInfo, SC);
6917
6918 if (R->getContainedDeducedType())
6919 ParsingInitForAutoVars.insert(NewVD);
6920
6921 if (D.isInvalidType())
6922 NewVD->setInvalidDecl();
6923
6925 NewVD->hasLocalStorage())
6926 checkNonTrivialCUnion(NewVD->getType(), NewVD->getLocation(),
6928 } else {
6929 bool Invalid = false;
6930
6931 if (DC->isRecord() && !CurContext->isRecord()) {
6932 // This is an out-of-line definition of a static data member.
6933 switch (SC) {
6934 case SC_None:
6935 break;
6936 case SC_Static:
6938 diag::err_static_out_of_line)
6940 break;
6941 case SC_Auto:
6942 case SC_Register:
6943 case SC_Extern:
6944 // [dcl.stc] p2: The auto or register specifiers shall be applied only
6945 // to names of variables declared in a block or to function parameters.
6946 // [dcl.stc] p6: The extern specifier cannot be used in the declaration
6947 // of class members
6948
6950 diag::err_storage_class_for_static_member)
6952 break;
6953 case SC_PrivateExtern:
6954 llvm_unreachable("C storage class in c++!");
6955 }
6956 }
6957
6958 if (SC == SC_Static && CurContext->isRecord()) {
6959 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
6960 // Walk up the enclosing DeclContexts to check for any that are
6961 // incompatible with static data members.
6962 const DeclContext *FunctionOrMethod = nullptr;
6963 const CXXRecordDecl *AnonStruct = nullptr;
6964 for (DeclContext *Ctxt = DC; Ctxt; Ctxt = Ctxt->getParent()) {
6965 if (Ctxt->isFunctionOrMethod()) {
6966 FunctionOrMethod = Ctxt;
6967 break;
6968 }
6969 const CXXRecordDecl *ParentDecl = dyn_cast<CXXRecordDecl>(Ctxt);
6970 if (ParentDecl && !ParentDecl->getDeclName()) {
6971 AnonStruct = ParentDecl;
6972 break;
6973 }
6974 }
6975 if (FunctionOrMethod) {
6976 // C++ [class.static.data]p5: A local class shall not have static data
6977 // members.
6979 diag::err_static_data_member_not_allowed_in_local_class)
6980 << Name << RD->getDeclName() << RD->getTagKind();
6981 } else if (AnonStruct) {
6982 // C++ [class.static.data]p4: Unnamed classes and classes contained
6983 // directly or indirectly within unnamed classes shall not contain
6984 // static data members.
6986 diag::err_static_data_member_not_allowed_in_anon_struct)
6987 << Name << AnonStruct->getTagKind();
6988 Invalid = true;
6989 } else if (RD->isUnion()) {
6990 // C++98 [class.union]p1: If a union contains a static data member,
6991 // the program is ill-formed. C++11 drops this restriction.
6994 ? diag::warn_cxx98_compat_static_data_member_in_union
6995 : diag::ext_static_data_member_in_union) << Name;
6996 }
6997 }
6998 }
6999
7000 // Match up the template parameter lists with the scope specifier, then
7001 // determine whether we have a template or a template specialization.
7002 bool InvalidScope = false;
7005 D.getCXXScopeSpec(),
7007 ? D.getName().TemplateId
7008 : nullptr,
7009 TemplateParamLists,
7010 /*never a friend*/ false, IsMemberSpecialization, InvalidScope);
7011 Invalid |= InvalidScope;
7012
7013 if (TemplateParams) {
7014 if (!TemplateParams->size() &&
7016 // There is an extraneous 'template<>' for this variable. Complain
7017 // about it, but allow the declaration of the variable.
7018 Diag(TemplateParams->getTemplateLoc(),
7019 diag::err_template_variable_noparams)
7020 << II
7021 << SourceRange(TemplateParams->getTemplateLoc(),
7022 TemplateParams->getRAngleLoc());
7023 TemplateParams = nullptr;
7024 } else {
7025 // Check that we can declare a template here.
7026 if (CheckTemplateDeclScope(S, TemplateParams))
7027 return nullptr;
7028
7030 // This is an explicit specialization or a partial specialization.
7031 IsVariableTemplateSpecialization = true;
7032 IsPartialSpecialization = TemplateParams->size() > 0;
7033 } else { // if (TemplateParams->size() > 0)
7034 // This is a template declaration.
7035 IsVariableTemplate = true;
7036
7037 // Only C++1y supports variable templates (N3651).
7040 ? diag::warn_cxx11_compat_variable_template
7041 : diag::ext_variable_template);
7042 }
7043 }
7044 } else {
7045 // Check that we can declare a member specialization here.
7046 if (!TemplateParamLists.empty() && IsMemberSpecialization &&
7047 CheckTemplateDeclScope(S, TemplateParamLists.back()))
7048 return nullptr;
7049 assert((Invalid ||
7051 "should have a 'template<>' for this decl");
7052 }
7053
7054 if (IsVariableTemplateSpecialization) {
7055 SourceLocation TemplateKWLoc =
7056 TemplateParamLists.size() > 0
7057 ? TemplateParamLists[0]->getTemplateLoc()
7058 : SourceLocation();
7060 S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
7062 if (Res.isInvalid())
7063 return nullptr;
7064 NewVD = cast<VarDecl>(Res.get());
7065 AddToScope = false;
7066 } else if (D.isDecompositionDeclarator()) {
7068 D.getIdentifierLoc(), R, TInfo, SC,
7069 Bindings);
7070 } else
7071 NewVD = VarDecl::Create(Context, DC, D.getBeginLoc(),
7072 D.getIdentifierLoc(), II, R, TInfo, SC);
7073
7074 // If this is supposed to be a variable template, create it as such.
7075 if (IsVariableTemplate) {
7076 NewTemplate =
7078 TemplateParams, NewVD);
7079 NewVD->setDescribedVarTemplate(NewTemplate);
7080 }
7081
7082 // If this decl has an auto type in need of deduction, make a note of the
7083 // Decl so we can diagnose uses of it in its own initializer.
7084 if (R->getContainedDeducedType())
7085 ParsingInitForAutoVars.insert(NewVD);
7086
7087 if (D.isInvalidType() || Invalid) {
7088 NewVD->setInvalidDecl();
7089 if (NewTemplate)
7090 NewTemplate->setInvalidDecl();
7091 }
7092
7093 SetNestedNameSpecifier(*this, NewVD, D);
7094
7095 // If we have any template parameter lists that don't directly belong to
7096 // the variable (matching the scope specifier), store them.
7097 unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
7098 if (TemplateParamLists.size() > VDTemplateParamLists)
7100 Context, TemplateParamLists.drop_back(VDTemplateParamLists));
7101 }
7102
7103 if (D.getDeclSpec().isInlineSpecified()) {
7104 if (!getLangOpts().CPlusPlus) {
7105 Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
7106 << 0;
7107 } else if (CurContext->isFunctionOrMethod()) {
7108 // 'inline' is not allowed on block scope variable declaration.
7110 diag::err_inline_declaration_block_scope) << Name
7112 } else {
7114 getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_inline_variable
7115 : diag::ext_inline_variable);
7116 NewVD->setInlineSpecified();
7117 }
7118 }
7119
7120 // Set the lexical context. If the declarator has a C++ scope specifier, the
7121 // lexical context will be different from the semantic context.
7123 if (NewTemplate)
7124 NewTemplate->setLexicalDeclContext(CurContext);
7125
7126 if (IsLocalExternDecl) {
7128 for (auto *B : Bindings)
7129 B->setLocalExternDecl();
7130 else
7131 NewVD->setLocalExternDecl();
7132 }
7133
7134 bool EmitTLSUnsupportedError = false;
7136 // C++11 [dcl.stc]p4:
7137 // When thread_local is applied to a variable of block scope the
7138 // storage-class-specifier static is implied if it does not appear
7139 // explicitly.
7140 // Core issue: 'static' is not implied if the variable is declared
7141 // 'extern'.
7142 if (NewVD->hasLocalStorage() &&
7143 (SCSpec != DeclSpec::SCS_unspecified ||
7145 !DC->isFunctionOrMethod()))
7147 diag::err_thread_non_global)
7149 else if (!Context.getTargetInfo().isTLSSupported()) {
7150 if (getLangOpts().CUDA || getLangOpts().OpenMPIsDevice ||
7151 getLangOpts().SYCLIsDevice) {
7152 // Postpone error emission until we've collected attributes required to
7153 // figure out whether it's a host or device variable and whether the
7154 // error should be ignored.
7155 EmitTLSUnsupportedError = true;
7156 // We still need to mark the variable as TLS so it shows up in AST with
7157 // proper storage class for other tools to use even if we're not going
7158 // to emit any code for it.
7159 NewVD->setTSCSpec(TSCS);
7160 } else
7162 diag::err_thread_unsupported);
7163 } else
7164 NewVD->setTSCSpec(TSCS);
7165 }
7166
7167 switch (D.getDeclSpec().getConstexprSpecifier()) {
7169 break;
7170
7173 diag::err_constexpr_wrong_decl_kind)
7174 << static_cast<int>(D.getDeclSpec().getConstexprSpecifier());
7175 LLVM_FALLTHROUGH;
7176
7178 NewVD->setConstexpr(true);
7180 // C++1z [dcl.spec.constexpr]p1:
7181 // A static data member declared with the constexpr specifier is
7182 // implicitly an inline variable.
7183 if (NewVD->isStaticDataMember() &&
7186 NewVD->setImplicitlyInline();
7187 break;
7188
7190 if (!NewVD->hasGlobalStorage())
7192 diag::err_constinit_local_variable);
7193 else
7197 break;
7198 }
7199
7200 // C99 6.7.4p3
7201 // An inline definition of a function with external linkage shall
7202 // not contain a definition of a modifiable object with static or
7203 // thread storage duration...
7204 // We only apply this when the function is required to be defined
7205 // elsewhere, i.e. when the function is not 'extern inline'. Note
7206 // that a local variable with thread storage duration still has to
7207 // be marked 'static'. Also note that it's possible to get these
7208 // semantics in C++ using __attribute__((gnu_inline)).
7209 if (SC == SC_Static && S->getFnParent() != nullptr &&
7210 !NewVD->getType().isConstQualified()) {
7212 if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
7214 diag::warn_static_local_in_extern_inline);
7216 }
7217 }
7218
7220 if (IsVariableTemplateSpecialization)
7221 Diag(NewVD->getLocation(), diag::err_module_private_specialization)
7222 << (IsPartialSpecialization ? 1 : 0)
7225 else if (IsMemberSpecialization)
7226 Diag(NewVD->getLocation(), diag::err_module_private_specialization)
7227 << 2
7229 else if (NewVD->hasLocalStorage())
7230 Diag(NewVD->getLocation(), diag::err_module_private_local)
7231 << 0 << NewVD
7235 else {
7236 NewVD->setModulePrivate();
7237 if (NewTemplate)
7238 NewTemplate->setModulePrivate();
7239 for (auto *B : Bindings)
7240 B->setModulePrivate();
7241 }
7242 }
7243
7244 if (getLangOpts().OpenCL) {
7245
7247
7248 diagnoseOpenCLTypes(S, *this, D, DC, NewVD->getType());
7249 }
7250
7251 // Handle attributes prior to checking for duplicates in MergeVarDecl
7252 ProcessDeclAttributes(S, NewVD, D);
7253
7254 if (getLangOpts().CUDA || getLangOpts().OpenMPIsDevice ||
7255 getLangOpts().SYCLIsDevice) {
7256 if (EmitTLSUnsupportedError &&
7258 (getLangOpts().OpenMPIsDevice &&
7261 diag::err_thread_unsupported);
7262
7263 if (EmitTLSUnsupportedError &&
7264 (LangOpts.SYCLIsDevice || (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)))
7265 targetDiag(D.getIdentifierLoc(), diag::err_thread_unsupported);
7266 // CUDA B.2.5: "__shared__ and __constant__ variables have implied static
7267 // storage [duration]."
7268 if (SC == SC_None && S->getFnParent() != nullptr &&
7269 (NewVD->hasAttr<CUDASharedAttr>() ||
7270 NewVD->hasAttr<CUDAConstantAttr>())) {
7271 NewVD->setStorageClass(SC_Static);
7272 }
7273 }
7274
7275 // Ensure that dllimport globals without explicit storage class are treated as
7276 // extern. The storage class is set above using parsed attributes. Now we can
7277 // check the VarDecl itself.
7278 assert(!NewVD->hasAttr<DLLImportAttr>() ||
7279 NewVD->getAttr<DLLImportAttr>()->isInherited() ||
7280 NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None);
7281
7282 // In auto-retain/release, infer strong retension for variables of
7283 // retainable type.
7284 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
7285 NewVD->setInvalidDecl();
7286
7287 // Handle GNU asm-label extension (encoded as an attribute).
7288 if (Expr *E = (Expr*)D.getAsmLabel()) {
7289 // The parser guarantees this is a string.
7291 StringRef Label = SE->getString();
7292 if (S->getFnParent() != nullptr) {
7293 switch (SC) {
7294 case SC_None:
7295 case SC_Auto:
7296 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
7297 break;
7298 case SC_Register:
7299 // Local Named register
7302 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
7303 break;
7304 case SC_Static:
7305 case SC_Extern:
7306 case SC_PrivateExtern:
7307 break;
7308 }
7309 } else if (SC == SC_Register) {
7310 // Global Named register
7311 if (DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) {
7312 const auto &TI = Context.getTargetInfo();
7313 bool HasSizeMismatch;
7314
7315 if (!TI.isValidGCCRegisterName(Label))
7316 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
7317 else if (!TI.validateGlobalRegisterVariable(Label,
7319 HasSizeMismatch))
7320 Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) << Label;
7321 else if (HasSizeMismatch)
7322 Diag(E->getExprLoc(), diag::err_asm_register_size_mismatch) << Label;
7323 }
7324
7325 if (!R->isIntegralType(Context) && !R->isPointerType()) {
7326 Diag(D.getBeginLoc(), diag::err_asm_bad_register_type);
7327 NewVD->setInvalidDecl(true);
7328 }
7329 }
7330
7332 /*IsLiteralLabel=*/true,
7333 SE->getStrTokenLoc(0)));
7334 } else if (!ExtnameUndeclaredIdentifiers.empty()) {
7335 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
7337 if (I != ExtnameUndeclaredIdentifiers.end()) {
7338 if (isDeclExternC(NewVD)) {
7339 NewVD->addAttr(I->second);
7341 } else
7342 Diag(NewVD->getLocation(), diag::warn_redefine_extname_not_applied)
7343 << /*Variable*/1 << NewVD;
7344 }
7345 }
7346
7347 // Find the shadowed declaration before filtering for scope.
7348 NamedDecl *ShadowedDecl = D.getCXXScopeSpec().isEmpty()
7350 : nullptr;
7351
7352 // Don't consider existing declarations that are in a different
7353 // scope and are out-of-semantic-context declarations (if the new
7354 // declaration has linkage).
7357 IsMemberSpecialization ||
7358 IsVariableTemplateSpecialization);
7359
7360 // Check whether the previous declaration is in the same block scope. This
7361 // affects whether we merge types with it, per C++11 [dcl.array]p3.
7362 if (getLangOpts().CPlusPlus &&
7363 NewVD->isLocalVarDecl() && NewVD->hasExternalStorage())
7365 Previous.isSingleResult() && !Previous.isShadowed() &&
7366 isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false));
7367
7368 if (!getLangOpts().CPlusPlus) {
7370 } else {
7371 // If this is an explicit specialization of a static data member, check it.
7372 if (IsMemberSpecialization && !NewVD->isInvalidDecl() &&
7374 NewVD->setInvalidDecl();
7375
7376 // Merge the decl with the existing one if appropriate.
7377 if (!Previous.empty()) {
7378 if (Previous.isSingleResult() &&
7379 isa<FieldDecl>(Previous.getFoundDecl()) &&
7380 D.getCXXScopeSpec().isSet()) {
7381 // The user tried to define a non-static data member
7382 // out-of-line (C++ [dcl.meaning]p1).
7383 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
7384 << D.getCXXScopeSpec().getRange();
7385 Previous.clear();
7386 NewVD->setInvalidDecl();
7387 }
7388 } else if (D.getCXXScopeSpec().isSet()) {
7389 // No previous declaration in the qualifying scope.
7390 Diag(D.getIdentifierLoc(), diag::err_no_member)
7391 << Name << computeDeclContext(D.getCXXScopeSpec(), true)
7392 << D.getCXXScopeSpec().getRange();
7393 NewVD->setInvalidDecl();
7394 }
7395
7396 if (!IsVariableTemplateSpecialization)
7398
7399 if (NewTemplate) {
7400 VarTemplateDecl *PrevVarTemplate =
7401 NewVD->getPreviousDecl()
7403 : nullptr;
7404
7405 // Check the template parameter list of this declaration, possibly
7406 // merging in the template parameter list from the previous variable
7407 // template declaration.
7409 TemplateParams,
7410 PrevVarTemplate ? PrevVarTemplate->getTemplateParameters()
7411 : nullptr,
7412 (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() &&
7413 DC->isDependentContext())
7415 : TPC_VarTemplate))
7416 NewVD->setInvalidDecl();
7417
7418 // If we are providing an explicit specialization of a static variable
7419 // template, make a note of that.
7420 if (PrevVarTemplate &&
7421 PrevVarTemplate->getInstantiatedFromMemberTemplate())
7422 PrevVarTemplate->setMemberSpecialization();
7423 }
7424 }
7425
7426 // Diagnose shadowed variables iff this isn't a redeclaration.
7427 if (ShadowedDecl && !D.isRedeclaration())
7428 CheckShadow(NewVD, ShadowedDecl, Previous);
7429
7430 ProcessPragmaWeak(S, NewVD);
7431
7432 // If this is the first declaration of an extern C variable, update
7433 // the map of such variables.
7434 if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() &&
7435 isIncompleteDeclExternC(*this, NewVD))
7437
7438 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
7440 Decl *ManglingContextDecl;
7441 std::tie(MCtx, ManglingContextDecl) =
7443 if (MCtx) {
7445 NewVD, MCtx->getManglingNumber(
7446 NewVD, getMSManglingNumber(getLangOpts(), S)));
7448 }
7449 }
7450
7451 // Special handling of variable named 'main'.
7452 if (Name.getAsIdentifierInfo() && Name.getAsIdentifierInfo()->isStr("main") &&
7454 !getLangOpts().Freestanding && !NewVD->getDescribedVarTemplate()) {
7455
7456 // C++ [basic.start.main]p3
7457 // A program that declares a variable main at global scope is ill-formed.
7458 if (getLangOpts().CPlusPlus)
7459 Diag(D.getBeginLoc(), diag::err_main_global_variable);
7460
7461 // In C, and external-linkage variable named main results in undefined
7462 // behavior.
7463 else if (NewVD->hasExternalFormalLinkage())
7464 Diag(D.getBeginLoc(), diag::warn_main_redefined);
7465 }
7466
7467 if (D.isRedeclaration() && !Previous.empty()) {
7468 NamedDecl *Prev = Previous.getRepresentativeDecl();
7469 checkDLLAttributeRedeclaration(*this, Prev, NewVD, IsMemberSpecialization,
7471 }
7472
7473 if (NewTemplate) {
7474 if (NewVD->isInvalidDecl())
7475 NewTemplate->setInvalidDecl();
7476 ActOnDocumentableDecl(NewTemplate);
7477 return NewTemplate;
7478 }
7479
7480 if (IsMemberSpecialization && !NewVD->isInvalidDecl())
7482
7483 return NewVD;
7484}
7485
7486/// Enum describing the %select options in diag::warn_decl_shadow.
7495
7496/// Determine what kind of declaration we're shadowing.
7498 const DeclContext *OldDC) {
7499 if (isa<TypeAliasDecl>(ShadowedDecl))
7500 return SDK_Using;
7501 else if (isa<TypedefDecl>(ShadowedDecl))
7502 return SDK_Typedef;
7503 else if (isa<RecordDecl>(OldDC))
7504 return isa<FieldDecl>(ShadowedDecl) ? SDK_Field : SDK_StaticMember;
7505
7506 return OldDC->isFileContext() ? SDK_Global : SDK_Local;
7507}
7508
7509/// Return the location of the capture if the given lambda captures the given
7510/// variable \p VD, or an invalid source location otherwise.
7512 const VarDecl *VD) {
7513 for (const Capture &Capture : LSI->Captures) {
7515 return Capture.getLocation();
7516 }
7517 return SourceLocation();
7518}
7519
7521 const LookupResult &R) {
7522 // Only diagnose if we're shadowing an unambiguous field or variable.
7524 return false;
7525
7526 // Return false if warning is ignored.
7527 return !Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc());
7528}
7529
7530/// Return the declaration shadowed by the given variable \p D, or null
7531/// if it doesn't shadow any declaration or shadowing warnings are disabled.
7533 const LookupResult &R) {
7535 return nullptr;
7536
7537 // Don't diagnose declarations at file scope.
7538 if (D->hasGlobalStorage())
7539 return nullptr;
7540
7541 NamedDecl *ShadowedDecl = R.getFoundDecl();
7542 return isa<VarDecl>(ShadowedDecl) || isa<FieldDecl>(ShadowedDecl)
7543 ? ShadowedDecl
7544 : nullptr;
7545}
7546
7547/// Return the declaration shadowed by the given typedef \p D, or null
7548/// if it doesn't shadow any declaration or shadowing warnings are disabled.
7550 const LookupResult &R) {
7551 // Don't warn if typedef declaration is part of a class
7552 if (D->getDeclContext()->isRecord())
7553 return nullptr;
7554
7556 return nullptr;
7557
7558 NamedDecl *ShadowedDecl = R.getFoundDecl();
7559 return isa<TypedefNameDecl>(ShadowedDecl) ? ShadowedDecl : nullptr;
7560}
7561
7562/// Diagnose variable or built-in function shadowing. Implements
7563/// -Wshadow.
7564///
7565/// This method is called whenever a VarDecl is added to a "useful"
7566/// scope.
7567///
7568/// \param ShadowedDecl the declaration that is shadowed by the given variable
7569/// \param R the lookup of the name
7570///
7572 const LookupResult &R) {
7573 DeclContext *NewDC = D->getDeclContext();
7574
7575 if (FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
7576 // Fields are not shadowed by variables in C++ static methods.
7577 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
7578 if (MD->isStatic())
7579 return;
7580
7581 // Fields shadowed by constructor parameters are a special case. Usually
7582 // the constructor initializes the field with the parameter.
7583 if (isa<CXXConstructorDecl>(NewDC))
7584 if (const auto PVD = dyn_cast<ParmVarDecl>(D)) {
7585 // Remember that this was shadowed so we can either warn about its
7586 // modification or its existence depending on warning settings.
7587 ShadowingDecls.insert({PVD->getCanonicalDecl(), FD});
7588 return;
7589 }
7590 }
7591
7592 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
7593 if (shadowedVar->isExternC()) {
7594 // For shadowing external vars, make sure that we point to the global
7595 // declaration, not a locally scoped extern declaration.
7596 for (auto I : shadowedVar->redecls())
7597 if (I->isFileVarDecl()) {
7598 ShadowedDecl = I;
7599 break;
7600 }
7601 }
7602
7603 DeclContext *OldDC = ShadowedDecl->getDeclContext()->getRedeclContext();
7604
7605 unsigned WarningDiag = diag::warn_decl_shadow;
7606 SourceLocation CaptureLoc;
7607 if (isa<VarDecl>(D) && isa<VarDecl>(ShadowedDecl) && NewDC &&
7608 isa<CXXMethodDecl>(NewDC)) {
7609 if (const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->getParent())) {
7610 if (RD->isLambda() && OldDC->Encloses(NewDC->getLexicalParent())) {
7611 if (RD->getLambdaCaptureDefault() == LCD_None) {
7612 // Try to avoid warnings for lambdas with an explicit capture list.
7613 const auto *LSI = cast<LambdaScopeInfo>(getCurFunction());
7614 // Warn only when the lambda captures the shadowed decl explicitly.
7615 CaptureLoc = getCaptureLocation(LSI, cast<VarDecl>(ShadowedDecl));
7616 if (CaptureLoc.isInvalid())
7617 WarningDiag = diag::warn_decl_shadow_uncaptured_local;
7618 } else {
7619 // Remember that this was shadowed so we can avoid the warning if the
7620 // shadowed decl isn't captured and the warning settings allow it.
7622 ->ShadowingDecls.push_back(
7623 {cast<VarDecl>(D), cast<VarDecl>(ShadowedDecl)});
7624 return;
7625 }
7626 }
7627
7628 if (cast<VarDecl>(ShadowedDecl)->hasLocalStorage()) {
7629 // A variable can't shadow a local variable in an enclosing scope, if
7630 // they are separated by a non-capturing declaration context.
7631 for (DeclContext *ParentDC = NewDC;
7632 ParentDC && !ParentDC->Equals(OldDC);
7633 ParentDC = getLambdaAwareParentOfDeclContext(ParentDC)) {
7634 // Only block literals, captured statements, and lambda expressions
7635 // can capture; other scopes don't.
7636 if (!isa<BlockDecl>(ParentDC) && !isa<CapturedDecl>(ParentDC) &&
7637 !isLambdaCallOperator(ParentDC)) {
7638 return;
7639 }
7640 }
7641 }
7642 }
7643 }
7644
7645 // Only warn about certain kinds of shadowing for class members.
7646 if (NewDC && NewDC->isRecord()) {
7647 // In particular, don't warn about shadowing non-class members.
7648 if (!OldDC->isRecord())
7649 return;
7650
7651 // TODO: should we warn about static data members shadowing
7652 // static data members from base classes?
7653
7654 // TODO: don't diagnose for inaccessible shadowed members.
7655 // This is hard to do perfectly because we might friend the
7656 // shadowing context, but that's just a false negative.
7657 }
7658
7659
7660 DeclarationName Name = R.getLookupName();
7661
7662 // Emit warning and note.
7663 if (getSourceManager().isInSystemMacro(R.getNameLoc()))
7664 return;
7665 ShadowedDeclKind Kind = computeShadowedDeclKind(ShadowedDecl, OldDC);
7666 Diag(R.getNameLoc(), WarningDiag) << Name << Kind << OldDC;
7667 if (!CaptureLoc.isInvalid())
7668 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
7669 << Name << /*explicitly*/ 1;
7670 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
7671}
7672
7673/// Diagnose shadowing for variables shadowed in the lambda record \p LambdaRD
7674/// when these variables are captured by the lambda.
7676 for (const auto &Shadow : LSI->ShadowingDecls) {
7677 const VarDecl *ShadowedDecl = Shadow.ShadowedDecl;
7678 // Try to avoid the warning when the shadowed decl isn't captured.
7679 SourceLocation CaptureLoc = getCaptureLocation(LSI, ShadowedDecl);
7680 const DeclContext *OldDC = ShadowedDecl->getDeclContext();
7681 Diag(Shadow.VD->getLocation(), CaptureLoc.isInvalid()
7682 ? diag::warn_decl_shadow_uncaptured_local
7683 : diag::warn_decl_shadow)
7684 << Shadow.VD->getDeclName()
7685 << computeShadowedDeclKind(ShadowedDecl, OldDC) << OldDC;
7686 if (!CaptureLoc.isInvalid())
7687 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
7688 << Shadow.VD->getDeclName() << /*explicitly*/ 0;
7689 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
7690 }
7691}
7692
7693/// Check -Wshadow without the advantage of a previous lookup.
7695 if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))
7696 return;
7697
7698 LookupResult R(*this, D->getDeclName(), D->getLocation(),
7700 LookupName(R, S);
7701 if (NamedDecl *ShadowedDecl = getShadowedDeclaration(D, R))
7702 CheckShadow(D, ShadowedDecl, R);
7703}
7704
7705/// Check if 'E', which is an expression that is about to be modified, refers
7706/// to a constructor parameter that shadows a field.
7708 // Quickly ignore expressions that can't be shadowing ctor parameters.
7709 if (!getLangOpts().CPlusPlus || ShadowingDecls.empty())
7710 return;
7711 E = E->IgnoreParenImpCasts();
7712 auto *DRE = dyn_cast<DeclRefExpr>(E);
7713 if (!DRE)
7714 return;
7715 const NamedDecl *D = cast<NamedDecl>(DRE->getDecl()->getCanonicalDecl());
7716 auto I = ShadowingDecls.find(D);
7717 if (I == ShadowingDecls.end())
7718 return;
7719 const NamedDecl *ShadowedDecl = I->second;
7720 const DeclContext *OldDC = ShadowedDecl->getDeclContext();
7721 Diag(Loc, diag::warn_modifying_shadowing_decl) << D << OldDC;
7722 Diag(D->getLocation(), diag::note_var_declared_here) << D;
7723 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
7724
7725 // Avoid issuing multiple warnings about the same decl.
7726 ShadowingDecls.erase(I);
7727}
7728
7729/// Check for conflict between this global or extern "C" declaration and
7730/// previous global or extern "C" declarations. This is only used in C++.
7731template<typename T>
7733 Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) {
7734 assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\"");
7735 NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName());
7736
7737 if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) {
7738 // The common case: this global doesn't conflict with any extern "C"
7739 // declaration.
7740 return false;
7741 }
7742
7743 if (Prev) {
7744 if (!IsGlobal || isIncompleteDeclExternC(S, ND)) {
7745 // Both the old and new declarations have C language linkage. This is a
7746 // redeclaration.
7747 Previous.clear();
7748 Previous.addDecl(Prev);
7749 return true;
7750 }
7751
7752 // This is a global, non-extern "C" declaration, and there is a previous
7753 // non-global extern "C" declaration. Diagnose if this is a variable
7754 // declaration.
7755 if (!isa<VarDecl>(ND))
7756 return false;
7757 } else {
7758 // The declaration is extern "C". Check for any declaration in the
7759 // translation unit which might conflict.
7760 if (IsGlobal) {
7761 // We have already performed the lookup into the translation unit.
7762 IsGlobal = false;
7763 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7764 I != E; ++I) {
7765 if (isa<VarDecl>(*I)) {
7766 Prev = *I;
7767 break;
7768 }
7769 }
7770 } else {
7772 S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName());
7773 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
7774 I != E; ++I) {
7775 if (isa<VarDecl>(*I)) {
7776 Prev = *I;
7777 break;
7778 }
7779 // FIXME: If we have any other entity with this name in global scope,
7780 // the declaration is ill-formed, but that is a defect: it breaks the
7781 // 'stat' hack, for instance. Only variables can have mangled name
7782 // clashes with extern "C" declarations, so only they deserve a
7783 // diagnostic.
7784 }
7785 }
7786
7787 if (!Prev)
7788 return false;
7789 }
7790
7791 // Use the first declaration's location to ensure we point at something which
7792 // is lexically inside an extern "C" linkage-spec.
7793 assert(Prev && "should have found a previous declaration to diagnose");
7794 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev))
7795 Prev = FD->getFirstDecl();
7796 else
7797 Prev = cast<VarDecl>(Prev)->getFirstDecl();
7798
7799 S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
7800 << IsGlobal << ND;
7801 S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict)
7802 << IsGlobal;
7803 return false;
7804}
7805
7806/// Apply special rules for handling extern "C" declarations. Returns \c true
7807/// if we have found that this is a redeclaration of some prior entity.
7808///
7809/// Per C++ [dcl.link]p6:
7810/// Two declarations [for a function or variable] with C language linkage
7811/// with the same name that appear in different scopes refer to the same
7812/// [entity]. An entity with C language linkage shall not be declared with
7813/// the same name as an entity in global scope.
7814template<typename T>
7817 if (!S.getLangOpts().CPlusPlus) {
7818 // In C, when declaring a global variable, look for a corresponding 'extern'
7819 // variable declared in function scope. We don't need this in C++, because
7820 // we find local extern decls in the surrounding file-scope DeclContext.
7821 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
7822 if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) {
7823 Previous.clear();
7824 Previous.addDecl(Prev);
7825 return true;
7826 }
7827 }
7828 return false;
7829 }
7830
7831 // A declaration in the translation unit can conflict with an extern "C"
7832 // declaration.
7833 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
7834 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous);
7835
7836 // An extern "C" declaration can conflict with a declaration in the
7837 // translation unit or can be a redeclaration of an extern "C" declaration
7838 // in another scope.
7839 if (isIncompleteDeclExternC(S,ND))
7840 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous);
7841
7842 // Neither global nor extern "C": nothing to do.
7843 return false;
7844}
7845
7847 // If the decl is already known invalid, don't check it.
7848 if (NewVD->isInvalidDecl())
7849 return;
7850
7851 QualType T = NewVD->getType();
7852
7853 // Defer checking an 'auto' type until its initializer is attached.
7854 if (T->isUndeducedType())
7855 return;
7856
7857 if (NewVD->hasAttrs())
7859
7860 if (T->isObjCObjectType()) {
7861 Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
7862 << FixItHint::CreateInsertion(NewVD->getLocation(), "*");
7864 NewVD->setType(T);
7865 }
7866
7867 // Emit an error if an address space was applied to decl with local storage.
7868 // This includes arrays of objects with address space qualifiers, but not
7869 // automatic variables that point to other address spaces.
7870 // ISO/IEC TR 18037 S5.1.2
7871 if (!getLangOpts().OpenCL && NewVD->hasLocalStorage() &&
7872 T.getAddressSpace() != LangAS::Default) {
7873 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl) << 0;
7874 NewVD->setInvalidDecl();
7875 return;
7876 }
7877
7878 // OpenCL v1.2 s6.8 - The static qualifier is valid only in program
7879 // scope.
7880 if (getLangOpts().OpenCLVersion == 120 &&
7881 !getOpenCLOptions().isEnabled("cl_clang_storage_class_specifiers") &&
7882 NewVD->isStaticLocal()) {
7883 Diag(NewVD->getLocation(), diag::err_static_function_scope);
7884 NewVD->setInvalidDecl();
7885 return;
7886 }
7887
7888 if (getLangOpts().OpenCL) {
7889 // OpenCL v2.0 s6.12.5 - The __block storage type is not supported.
7890 if (NewVD->hasAttr<BlocksAttr>()) {
7891 Diag(NewVD->getLocation(), diag::err_opencl_block_storage_type);
7892 return;
7893 }
7894
7895 if (T->isBlockPointerType()) {
7896 // OpenCL v2.0 s6.12.5 - Any block declaration must be const qualified and
7897 // can't use 'extern' storage class.
7898 if (!T.isConstQualified()) {
7899 Diag(NewVD->getLocation(), diag::err_opencl_invalid_block_declaration)
7900 << 0 /*const*/;
7901 NewVD->setInvalidDecl();
7902 return;
7903 }
7904 if (NewVD->hasExternalStorage()) {
7905 Diag(NewVD->getLocation(), diag::err_opencl_extern_block_declaration);
7906 NewVD->setInvalidDecl();
7907 return;
7908 }
7909 }
7910 // OpenCL C v1.2 s6.5 - All program scope variables must be declared in the
7911 // __constant address space.
7912 // OpenCL C v2.0 s6.5.1 - Variables defined at program scope and static
7913 // variables inside a function can also be declared in the global
7914 // address space.
7915 // C++ for OpenCL inherits rule from OpenCL C v2.0.
7916 // FIXME: Adding local AS in C++ for OpenCL might make sense.
7917 if (NewVD->isFileVarDecl() || NewVD->isStaticLocal() ||
7918 NewVD->hasExternalStorage()) {
7919 if (!T->isSamplerT() &&
7920 !T->isDependentType() &&
7921 !(T.getAddressSpace() == LangAS::opencl_constant ||
7922 (T.getAddressSpace() == LangAS::opencl_global &&
7923 (getLangOpts().OpenCLVersion == 200 ||
7924 getLangOpts().OpenCLCPlusPlus)))) {
7925 int Scope = NewVD->isStaticLocal() | NewVD->hasExternalStorage() << 1;
7926 if (getLangOpts().OpenCLVersion == 200 || getLangOpts().OpenCLCPlusPlus)
7927 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
7928 << Scope << "global or constant";
7929 else
7930 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
7931 << Scope << "constant";
7932 NewVD->setInvalidDecl();
7933 return;
7934 }
7935 } else {
7936 if (T.getAddressSpace() == LangAS::opencl_global) {
7937 Diag(NewVD->getLocation(), diag::err_opencl_function_variable)
7938 << 1 /*is any function*/ << "global";
7939 NewVD->setInvalidDecl();
7940 return;
7941 }
7942 if (T.getAddressSpace() == LangAS::opencl_constant ||
7943 T.getAddressSpace() == LangAS::opencl_local) {
7945 // OpenCL v1.1 s6.5.2 and s6.5.3: no local or constant variables
7946 // in functions.
7947 if (FD && !FD->hasAttr<OpenCLKernelAttr>()) {
7948 if (T.getAddressSpace() == LangAS::opencl_constant)
7949 Diag(NewVD->getLocation(), diag::err_opencl_function_variable)
7950 << 0 /*non-kernel only*/ << "constant";
7951 else
7952 Diag(NewVD->getLocation(), diag::err_opencl_function_variable)
7953 << 0 /*non-kernel only*/ << "local";
7954 NewVD->setInvalidDecl();
7955 return;
7956 }
7957 // OpenCL v2.0 s6.5.2 and s6.5.3: local and constant variables must be
7958 // in the outermost scope of a kernel function.
7959 if (FD && FD->hasAttr<OpenCLKernelAttr>()) {
7960 if (!getCurScope()->isFunctionScope()) {
7961 if (T.getAddressSpace() == LangAS::opencl_constant)
7962 Diag(NewVD->getLocation(), diag::err_opencl_addrspace_scope)
7963 << "constant";
7964 else
7965 Diag(NewVD->getLocation(), diag::err_opencl_addrspace_scope)
7966 << "local";
7967 NewVD->setInvalidDecl();
7968 return;
7969 }
7970 }
7971 } else if (T.getAddressSpace() != LangAS::opencl_private &&
7972 // If we are parsing a template we didn't deduce an addr
7973 // space yet.
7974 T.getAddressSpace() != LangAS::Default) {
7975 // Do not allow other address spaces on automatic variable.
7976 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl) << 1;
7977 NewVD->setInvalidDecl();
7978 return;
7979 }
7980 }
7981 }
7982
7983 if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
7984 && !NewVD->hasAttr<BlocksAttr>()) {
7985 if (getLangOpts().getGC() != LangOptions::NonGC)
7986 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
7987 else {
7988 assert(!getLangOpts().ObjCAutoRefCount);
7989 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
7990 }
7991 }
7992
7993 bool isVM = T->isVariablyModifiedType();
7994 if (isVM || NewVD->hasAttr<CleanupAttr>() ||
7995 NewVD->hasAttr<BlocksAttr>())
7997
7998 if ((isVM && NewVD->hasLinkage()) ||
7999 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
8000 bool SizeIsNegative;
8001 llvm::APSInt Oversized;
8003 NewVD->getTypeSourceInfo(), Context, SizeIsNegative, Oversized);
8004 QualType FixedT;
8005 if (FixedTInfo && T == NewVD->getTypeSourceInfo()->getType())
8006 FixedT = FixedTInfo->getType();
8007 else if (FixedTInfo) {
8008 // Type and type-as-written are canonically different. We need to fix up
8009 // both types separately.
8010 FixedT = TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative,
8011 Oversized);
8012 }
8013 if ((!FixedTInfo || FixedT.isNull()) && T->isVariableArrayType()) {
8015 // FIXME: This won't give the correct result for
8016 // int a[10][n];
8017 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
8018
8019 if (NewVD->isFileVarDecl())
8020 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
8021 << SizeRange;
8022 else if (NewVD->isStaticLocal())
8023 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
8024 << SizeRange;
8025 else
8026 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
8027 << SizeRange;
8028 NewVD->setInvalidDecl();
8029 return;
8030 }
8031
8032 if (!FixedTInfo) {
8033 if (NewVD->isFileVarDecl())
8034 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
8035 else
8036 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
8037 NewVD->setInvalidDecl();
8038 return;
8039 }
8040
8041 Diag(NewVD->getLocation(), diag::ext_vla_folded_to_constant);
8042 NewVD->setType(FixedT);
8043 NewVD->setTypeSourceInfo(FixedTInfo);
8044 }
8045
8046 if (T->isVoidType()) {
8047 // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names
8048 // of objects and functions.
8050 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
8051 << T;
8052 NewVD->setInvalidDecl();
8053 return;
8054 }
8055 }
8056
8057 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
8058 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
8059 NewVD->setInvalidDecl();
8060 return;
8061 }
8062
8063 if (!NewVD->hasLocalStorage() && T->isSizelessType()) {
8064 Diag(NewVD->getLocation(), diag::err_sizeless_nonlocal) << T;
8065 NewVD->setInvalidDecl();
8066 return;
8067 }
8068
8069 if (isVM && NewVD->hasAttr<BlocksAttr>()) {
8070 Diag(NewVD->getLocation(), diag::err_block_on_vm);
8071 NewVD->setInvalidDecl();
8072 return;
8073 }
8074
8075 if (NewVD->isConstexpr() && !T->isDependentType() &&
8076 RequireLiteralType(NewVD->getLocation(), T,
8077 diag::err_constexpr_var_non_literal)) {
8078 NewVD->setInvalidDecl();
8079 return;
8080 }
8081
8082 // PPC MMA non-pointer types are not allowed as non-local variable types.
8083 if (Context.getTargetInfo().getTriple().isPPC64() &&
8084 !NewVD->isLocalVarDecl() &&
8085 CheckPPCMMAType(T, NewVD->getLocation())) {
8086 NewVD->setInvalidDecl();
8087 return;
8088 }
8089}
8090
8091/// Perform semantic checking on a newly-created variable
8092/// declaration.
8093///
8094/// This routine performs all of the type-checking required for a
8095/// variable declaration once it has been built. It is used both to
8096/// check variables after they have been parsed and their declarators
8097/// have been translated into a declaration, and to check variables
8098/// that have been instantiated from a template.
8099///
8100/// Sets NewVD->isInvalidDecl() if an error was encountered.
8101///
8102/// Returns true if the variable declaration is a redeclaration.
8105
8106 // If the decl is already known invalid, don't check it.
8107 if (NewVD->isInvalidDecl())
8108 return false;
8109
8110 // If we did not find anything by this name, look for a non-visible
8111 // extern "C" declaration with the same name.
8112 if (Previous.empty() &&
8114 Previous.setShadowed();
8115
8116 if (!Previous.empty()) {
8117 MergeVarDecl(NewVD, Previous);
8118 return true;
8119 }
8120 return false;
8121}
8122
8123/// AddOverriddenMethods - See if a method overrides any in the base classes,
8124/// and if so, check that it's a valid override and remember it.
8127
8128 // Look for methods in base classes that this method might override.
8129 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
8130 /*DetectVirtual=*/false);
8131 auto VisitBase = [&] (const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
8132 CXXRecordDecl *BaseRecord = Specifier->getType()->getAsCXXRecordDecl();
8133 DeclarationName Name = MD->getDeclName();
8134
8135 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
8136 // We really want to find the base class destructor here.
8137 QualType T = Context.getTypeDeclType(BaseRecord);
8140 }
8141
8142 for (NamedDecl *BaseND : BaseRecord->lookup(Name)) {
8143 CXXMethodDecl *BaseMD =
8144 dyn_cast<CXXMethodDecl>(BaseND->getCanonicalDecl());
8145 if (!BaseMD || !BaseMD->isVirtual() ||
8146 IsOverload(MD, BaseMD, /*UseMemberUsingDeclRules=*/false,
8147 /*ConsiderCudaAttrs=*/true,
8148 // C++2a [class.virtual]p2 does not consider requires
8149 // clauses when overriding.
8150 /*ConsiderRequiresClauses=*/false))
8151 continue;
8152
8153 if (Overridden.insert(BaseMD).second) {
8154 MD->addOverriddenMethod(BaseMD);
8159 }
8160
8161 // A method can only override one function from each base class. We
8162 // don't track indirectly overridden methods from bases of bases.
8163 return true;
8164 }
8165
8166 return false;
8167 };
8168
8169 DC->lookupInBases(VisitBase, Paths);
8170 return !Overridden.empty();
8171}
8172
8173namespace {
8174 // Struct for holding all of the extra arguments needed by
8175 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
8176 struct ActOnFDArgs {
8177 Scope *S;
8178 Declarator &D;
8179 MultiTemplateParamsArg TemplateParamLists;
8180 bool AddToScope;
8181 };
8182} // end anonymous namespace
8183
8184namespace {
8185
8186// Callback to only accept typo corrections that have a non-zero edit distance.
8187// Also only accept corrections that have the same parent decl.
8188class DifferentNameValidatorCCC final : public CorrectionCandidateCallback {
8189 public:
8190 DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD,
8192 : Context(Context), OriginalFD(TypoFD),
8193 ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {}
8194
8195 bool ValidateCandidate(const TypoCorrection &candidate) override {
8196 if (candidate.getEditDistance() == 0)
8197 return false;
8198
8199 SmallVector<unsigned, 1> MismatchedParams;
8200 for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(),
8201 CDeclEnd = candidate.end();
8202 CDecl != CDeclEnd; ++CDecl) {
8203 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
8204
8205 if (FD && !FD->hasBody() &&
8206 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
8207 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
8209 if (Parent && Parent->getCanonicalDecl() == ExpectedParent)
8210 return true;
8211 } else if (!ExpectedParent) {
8212 return true;
8213 }
8214 }
8215 }
8216
8217 return false;
8218 }
8219
8220 std::unique_ptr<CorrectionCandidateCallback> clone() override {
8221 return std::make_unique<DifferentNameValidatorCCC>(*this);
8222 }
8223
8224 private:
8225 ASTContext &Context;
8226 FunctionDecl *OriginalFD;
8227 CXXRecordDecl *ExpectedParent;
8228};
8229
8230} // end anonymous namespace
8231
8235
8236/// Generate diagnostics for an invalid function redeclaration.
8237///
8238/// This routine handles generating the diagnostic messages for an invalid
8239/// function redeclaration, including finding possible similar declarations
8240/// or performing typo correction if there are no previous declarations with
8241/// the same name.
8242///
8243/// Returns a NamedDecl iff typo correction was performed and substituting in
8244/// the new declaration name does not cause new errors.
8246 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
8247 ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) {
8248 DeclarationName Name = NewFD->getDeclName();
8249 DeclContext *NewDC = NewFD->getDeclContext();
8250 SmallVector<unsigned, 1> MismatchedParams;
8252 TypoCorrection Correction;
8253 bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
8254 unsigned DiagMsg =
8255 IsLocalFriend ? diag::err_no_matching_local_friend :
8256 NewFD->getFriendObjectKind() ? diag::err_qualified_friend_no_match :
8257 diag::err_member_decl_does_not_match;
8258 LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
8259 IsLocalFriend ? Sema::LookupLocalFriendName
8262
8263 NewFD->setInvalidDecl();
8264 if (IsLocalFriend)
8265 SemaRef.LookupName(Prev, S);
8266 else
8267 SemaRef.LookupQualifiedName(Prev, NewDC);
8268 assert(!Prev.isAmbiguous() &&
8269 "Cannot have an ambiguity in previous-declaration lookup");
8270 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
8271 DifferentNameValidatorCCC CCC(SemaRef.Context, NewFD,
8272 MD ? MD->getParent() : nullptr);
8273 if (!Prev.empty()) {
8274 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
8275 Func != FuncEnd; ++Func) {
8276 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
8277 if (FD &&
8278 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
8279 // Add 1 to the index so that 0 can mean the mismatch didn't
8280 // involve a parameter
8281 unsigned ParamNum =
8282 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
8283 NearMatches.push_back(std::make_pair(FD, ParamNum));
8284 }
8285 }
8286 // If the qualified name lookup yielded nothing, try typo correction
8287 } else if ((Correction = SemaRef.CorrectTypo(
8288 Prev.getLookupNameInfo(), Prev.getLookupKind(), S,
8289 &ExtraArgs.D.getCXXScopeSpec(), CCC, Sema::CTK_ErrorRecovery,
8290 IsLocalFriend ? nullptr : NewDC))) {
8291 // Set up everything for the call to ActOnFunctionDeclarator
8292 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
8293 ExtraArgs.D.getIdentifierLoc());
8294 Previous.clear();
8295 Previous.setLookupName(Correction.getCorrection());
8296 for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
8297 CDeclEnd = Correction.end();
8298 CDecl != CDeclEnd; ++CDecl) {
8299 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
8300 if (FD && !FD->hasBody() &&
8301 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
8302 Previous.addDecl(FD);
8303 }
8304 }
8305 bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
8306
8308 // Retry building the function declaration with the new previous
8309 // declarations, and with errors suppressed.
8310 {
8311 // Trap errors.
8312 Sema::SFINAETrap Trap(SemaRef);
8313
8314 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the
8315 // pieces need to verify the typo-corrected C++ declaration and hopefully
8316 // eliminate the need for the parameter pack ExtraArgs.
8318 ExtraArgs.S, ExtraArgs.D,
8319 Correction.getCorrectionDecl()->getDeclContext(),
8320 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
8321 ExtraArgs.AddToScope);
8322
8323 if (Trap.hasErrorOccurred())
8324 Result = nullptr;
8325 }
8326
8327 if (Result) {
8328 // Determine which correction we picked.
8329 Decl *Canonical = Result->getCanonicalDecl();
8330 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
8331 I != E; ++I)
8332 if ((*I)->getCanonicalDecl() == Canonical)
8333 Correction.setCorrectionDecl(*I);
8334
8335 // Let Sema know about the correction.
8337 SemaRef.diagnoseTypo(
8338 Correction,
8339 SemaRef.PDiag(IsLocalFriend
8340 ? diag::err_no_matching_local_friend_suggest
8341 : diag::err_member_decl_does_not_match_suggest)
8342 << Name << NewDC << IsDefinition);
8343 return Result;
8344 }
8345
8346 // Pretend the typo correction never occurred
8347 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
8348 ExtraArgs.D.getIdentifierLoc());
8349 ExtraArgs.D.setRedeclaration(wasRedeclaration);
8350 Previous.clear();
8351 Previous.setLookupName(Name);
8352 }
8353
8354 SemaRef.Diag(NewFD->getLocation(), DiagMsg)
8355 << Name << NewDC << IsDefinition << NewFD->getLocation();
8356
8357 bool NewFDisConst = false;
8358 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
8359 NewFDisConst = NewMD->isConst();
8360
8361 for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator
8362 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
8363 NearMatch != NearMatchEnd; ++NearMatch) {
8364 FunctionDecl *FD = NearMatch->first;
8365 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
8366 bool FDisConst = MD && MD->isConst();
8367 bool IsMember = MD || !IsLocalFriend;
8368
8369 // FIXME: These notes are poorly worded for the local friend case.
8370 if (unsigned Idx = NearMatch->second) {
8371 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
8372 SourceLocation Loc = FDParam->getTypeSpecStartLoc();
8373 if (Loc.isInvalid()) Loc = FD->getLocation();
8374 SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match
8375 : diag::note_local_decl_close_param_match)
8376 << Idx << FDParam->getType()
8377 << NewFD->getParamDecl(Idx - 1)->getType();
8378 } else if (FDisConst != NewFDisConst) {
8379 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
8380 << NewFDisConst << FD->getSourceRange().getEnd();
8381 } else
8382 SemaRef.Diag(FD->getLocation(),
8383 IsMember ? diag::note_member_def_close_match
8384 : diag::note_local_decl_close_match);
8385 }
8386 return nullptr;
8387}
8388
8390 switch (D.getDeclSpec().getStorageClassSpec()) {
8391 default: llvm_unreachable("Unknown storage class!");
8392 case DeclSpec::SCS_auto:
8396 diag::err_typecheck_sclass_func);
8398 D.setInvalidType();
8399 break;
8400 case DeclSpec::SCS_unspecified: break;
8403 return SC_None;
8404 return SC_Extern;
8405 case DeclSpec::SCS_static: {
8407 // C99 6.7.1p5:
8408 // The declaration of an identifier for a function that has
8409 // block scope shall have no explicit storage-class specifier
8410 // other than extern
8411 // See also (C++ [dcl.stc]p4).
8413 diag::err_static_block_func);
8414 break;
8415 } else
8416 return SC_Static;
8417 }
8419 }
8420
8421 // No explicit storage class has already been returned
8422 return SC_None;
8423}
8424
8426 DeclContext *DC, QualType &R,
8427 TypeSourceInfo *TInfo,
8428 StorageClass SC,
8429 bool &IsVirtualOkay) {
8430 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
8431 DeclarationName Name = NameInfo.getName();
8432
8433 FunctionDecl *NewFD = nullptr;
8434 bool isInline = D.getDeclSpec().isInlineSpecified();
8435
8436 if (!SemaRef.getLangOpts().CPlusPlus) {
8437 // Determine whether the function was written with a
8438 // prototype. This true when:
8439 // - there is a prototype in the declarator, or
8440 // - the type R of the function is some kind of typedef or other non-
8441 // attributed reference to a type name (which eventually refers to a
8442 // function type).
8443 bool HasPrototype =
8446
8447 NewFD = FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), NameInfo,
8448 R, TInfo, SC, isInline, HasPrototype,
8450 /*TrailingRequiresClause=*/nullptr);
8451 if (D.isInvalidType())
8452 NewFD->setInvalidDecl();
8453
8454 return NewFD;
8455 }
8456
8458
8460 if (ConstexprKind == ConstexprSpecKind::Constinit) {
8461 SemaRef.Diag(D.getDeclSpec().getConstexprSpecLoc(),
8462 diag::err_constexpr_wrong_decl_kind)
8463 << static_cast<int>(ConstexprKind);
8464 ConstexprKind = ConstexprSpecKind::Unspecified;
8466 }
8467 Expr *TrailingRequiresClause = D.getTrailingRequiresClause();
8468
8469 // Check that the return type is not an abstract class type.
8470 // For record types, this is done by the AbstractClassUsageDiagnoser once
8471 // the class has been completely parsed.
8472 if (!DC->isRecord() &&
8473 SemaRef.RequireNonAbstractType(
8475 diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
8476 D.setInvalidType();
8477
8478 if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
8479 // This is a C++ constructor declaration.
8480 assert(DC->isRecord() &&
8481 "Constructors can only be declared in a member context");
8482
8483 R = SemaRef.CheckConstructorDeclarator(D, R, SC);
8485 SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
8486 TInfo, ExplicitSpecifier, isInline,
8487 /*isImplicitlyDeclared=*/false, ConstexprKind, InheritedConstructor(),
8488 TrailingRequiresClause);
8489
8490 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
8491 // This is a C++ destructor declaration.
8492 if (DC->isRecord()) {
8493 R = SemaRef.CheckDestructorDeclarator(D, R, SC);
8494 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
8496 SemaRef.Context, Record, D.getBeginLoc(), NameInfo, R, TInfo,
8497 isInline, /*isImplicitlyDeclared=*/false, ConstexprKind,
8498 TrailingRequiresClause);
8499
8500 // If the destructor needs an implicit exception specification, set it
8501 // now. FIXME: It'd be nice to be able to create the right type to start
8502 // with, but the type needs to reference the destructor declaration.
8503 if (SemaRef.getLangOpts().CPlusPlus11)
8504 SemaRef.AdjustDestructorExceptionSpec(NewDD);
8505
8506 IsVirtualOkay = true;
8507 return NewDD;
8508
8509 } else {
8510 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
8511 D.setInvalidType();
8512
8513 // Create a FunctionDecl to satisfy the function definition parsing
8514 // code path.
8515 return FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(),
8516 D.getIdentifierLoc(), Name, R, TInfo, SC,
8517 isInline,
8518 /*hasPrototype=*/true, ConstexprKind,
8519 TrailingRequiresClause);
8520 }
8521
8522 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
8523 if (!DC->isRecord()) {
8524 SemaRef.Diag(D.getIdentifierLoc(),
8525 diag::err_conv_function_not_member);
8526 return nullptr;
8527 }
8528
8529 SemaRef.CheckConversionDeclarator(D, R, SC);
8530 if (D.isInvalidType())
8531 return nullptr;
8532
8533 IsVirtualOkay = true;
8535 SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
8536 TInfo, isInline, ExplicitSpecifier, ConstexprKind, SourceLocation(),
8537 TrailingRequiresClause);
8538
8539 } else if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
8540 if (TrailingRequiresClause)
8541 SemaRef.Diag(TrailingRequiresClause->getBeginLoc(),
8542 diag::err_trailing_requires_clause_on_deduction_guide)
8543 << TrailingRequiresClause->getSourceRange();
8544 SemaRef.CheckDeductionGuideDeclarator(D, R, SC);
8545
8546 return CXXDeductionGuideDecl::Create(SemaRef.Context, DC, D.getBeginLoc(),
8547 ExplicitSpecifier, NameInfo, R, TInfo,
8548 D.getEndLoc());
8549 } else if (DC->isRecord()) {
8550 // If the name of the function is the same as the name of the record,
8551 // then this must be an invalid constructor that has a return type.
8552 // (The parser checks for a return type and makes the declarator a
8553 // constructor if it has no return type).
8554 if (Name.getAsIdentifierInfo() &&
8555 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
8556 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
8559 return nullptr;
8560 }
8561
8562 // This is a C++ method declaration.
8564 SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
8565 TInfo, SC, isInline, ConstexprKind, SourceLocation(),
8566 TrailingRequiresClause);
8567 IsVirtualOkay = !Ret->isStatic();
8568 return Ret;
8569 } else {
8570 bool isFriend =
8571 SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified();
8572 if (!isFriend && SemaRef.CurContext->isRecord())
8573 return nullptr;
8574
8575 // Determine whether the function was written with a
8576 // prototype. This true when:
8577 // - we're in C++ (where every function has a prototype),
8578 return FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), NameInfo,
8579 R, TInfo, SC, isInline, true /*HasPrototype*/,
8580 ConstexprKind, TrailingRequiresClause);
8581 }
8582}
8583
8592
8594 // Size dependent types are just typedefs to normal integer types
8595 // (e.g. unsigned long), so we cannot distinguish them from other typedefs to
8596 // integers other than by their names.
8597 StringRef SizeTypeNames[] = {"size_t", "intptr_t", "uintptr_t", "ptrdiff_t"};
8598
8599 // Remove typedefs one by one until we reach a typedef
8600 // for a size dependent type.
8601 QualType DesugaredTy = Ty;
8602 do {
8603 ArrayRef<StringRef> Names(SizeTypeNames);
8604 auto Match = llvm::find(Names, DesugaredTy.getUnqualifiedType().getAsString());
8605 if (Names.end() != Match)
8606 return true;
8607
8608 Ty = DesugaredTy;
8609 DesugaredTy = Ty.getSingleStepDesugaredType(C);
8610 } while (DesugaredTy != Ty);
8611
8612 return false;
8613}
8614
8616 if (PT->isPointerType()) {
8617 QualType PointeeType = PT->getPointeeType();
8618 if (PointeeType.getAddressSpace() == LangAS::opencl_generic ||
8619 PointeeType.getAddressSpace() == LangAS::opencl_private ||
8620 PointeeType.getAddressSpace() == LangAS::Default)
8622
8623 if (PointeeType->isPointerType()) {
8624 // This is a pointer to pointer parameter.
8625 // Recursively check inner type.
8626 OpenCLParamType ParamKind = getOpenCLKernelParameterType(S, PointeeType);
8627 if (ParamKind == InvalidAddrSpacePtrKernelParam ||
8628 ParamKind == InvalidKernelParam)
8629 return ParamKind;
8630
8631 return PtrPtrKernelParam;
8632 }
8633 return PtrKernelParam;
8634 }
8635
8636 // OpenCL v1.2 s6.9.k:
8637 // Arguments to kernel functions in a program cannot be declared with the
8638 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
8639 // uintptr_t or a struct and/or union that contain fields declared to be one
8640 // of these built-in scalar types.
8642 return InvalidKernelParam;
8643
8644 if (PT->isImageType())
8645 return PtrKernelParam;
8646
8647 if (PT->isBooleanType() || PT->isEventT() || PT->isReserveIDT())
8648 return InvalidKernelParam;
8649
8650 // OpenCL extension spec v1.2 s9.5:
8651 // This extension adds support for half scalar and vector types as built-in
8652 // types that can be used for arithmetic operations, conversions etc.
8653 if (!S.getOpenCLOptions().isEnabled("cl_khr_fp16") && PT->isHalfType())
8654 return InvalidKernelParam;
8655
8656 if (PT->isRecordType())
8657 return RecordKernelParam;
8658
8659 // Look into an array argument to check if it has a forbidden type.
8660 if (PT->isArrayType()) {
8661 const Type *UnderlyingTy = PT->getPointeeOrArrayElementType();
8662 // Call ourself to check an underlying type of an array. Since the
8663 // getPointeeOrArrayElementType returns an innermost type which is not an
8664 // array, this recursive call only happens once.
8665 return getOpenCLKernelParameterType(S, QualType(UnderlyingTy, 0));
8666 }
8667
8668 return ValidKernelParam;
8669}
8670
8672 Sema &S,
8673 Declarator &D,
8674 ParmVarDecl *Param,
8675 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
8676 QualType PT = Param->getType();
8677
8678 // Cache the valid types we encounter to avoid rechecking structs that are
8679 // used again
8680 if (ValidTypes.count(PT.getTypePtr()))
8681 return;
8682
8683 switch (getOpenCLKernelParameterType(S, PT)) {
8684 case PtrPtrKernelParam:
8685 // OpenCL v3.0 s6.11.a:
8686 // A kernel function argument cannot be declared as a pointer to a pointer
8687 // type. [...] This restriction only applies to OpenCL C 1.2 or below.
8688 if (S.getLangOpts().OpenCLVersion < 120 &&
8689 !S.getLangOpts().OpenCLCPlusPlus) {
8690 S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
8691 D.setInvalidType();
8692 return;
8693 }
8694
8695 ValidTypes.insert(PT.getTypePtr());
8696 return;
8697
8699 // OpenCL v1.0 s6.5:
8700 // __kernel function arguments declared to be a pointer of a type can point
8701 // to one of the following address spaces only : __global, __local or
8702 // __constant.
8703 S.Diag(Param->getLocation(), diag::err_kernel_arg_address_space);
8704 D.setInvalidType();
8705 return;
8706
8707 // OpenCL v1.2 s6.9.k:
8708 // Arguments to kernel functions in a program cannot be declared with the
8709 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
8710 // uintptr_t or a struct and/or union that contain fields declared to be
8711 // one of these built-in scalar types.
8712
8713 case InvalidKernelParam:
8714 // OpenCL v1.2 s6.8 n:
8715 // A kernel function argument cannot be declared
8716 // of event_t type.
8717 // Do not diagnose half type since it is diagnosed as invalid argument
8718 // type for any function elsewhere.
8719 if (!PT->isHalfType()) {
8720 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
8721
8722 // Explain what typedefs are involved.
8723 const TypedefType *Typedef = nullptr;
8724 while ((Typedef = PT->getAs<TypedefType>())) {
8725 SourceLocation Loc = Typedef->getDecl()->getLocation();
8726 // SourceLocation may be invalid for a built-in type.
8727 if (Loc.isValid())
8728 S.Diag(Loc, diag::note_entity_declared_at) << PT;
8729 PT = Typedef->desugar();
8730 }
8731 }
8732
8733 D.setInvalidType();
8734 return;
8735
8736 case PtrKernelParam:
8737 case ValidKernelParam:
8738 ValidTypes.insert(PT.getTypePtr());
8739 return;
8740
8741 case RecordKernelParam:
8742 break;
8743 }
8744
8745 // Track nested structs we will inspect
8747
8748 // Track where we are in the nested structs. Items will migrate from
8749 // VisitStack to HistoryStack as we do the DFS for bad field.
8751 HistoryStack.push_back(nullptr);
8752
8753 // At this point we already handled everything except of a RecordType or
8754 // an ArrayType of a RecordType.
8755 assert((PT->isArrayType() || PT->isRecordType()) && "Unexpected type.");
8756 const RecordType *RecTy =
8758 const RecordDecl *OrigRecDecl = RecTy->getDecl();
8759
8760 VisitStack.push_back(RecTy->getDecl());
8761 assert(VisitStack.back() && "First decl null?");
8762
8763 do {
8764 const Decl *Next = VisitStack.pop_back_val();
8765 if (!Next) {
8766 assert(!HistoryStack.empty());
8767 // Found a marker, we have gone up a level
8768 if (const FieldDecl *Hist = HistoryStack.pop_back_val())
8769 ValidTypes.insert(Hist->getType().getTypePtr());
8770
8771 continue;
8772 }
8773
8774 // Adds everything except the original parameter declaration (which is not a
8775 // field itself) to the history stack.
8776 const RecordDecl *RD;
8777 if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
8778 HistoryStack.push_back(Field);
8779
8780 QualType FieldTy = Field->getType();
8781 // Other field types (known to be valid or invalid) are handled while we
8782 // walk around RecordDecl::fields().
8783 assert((FieldTy->isArrayType() || FieldTy->isRecordType()) &&
8784 "Unexpected type.");
8785 const Type *FieldRecTy = FieldTy->getPointeeOrArrayElementType();
8786
8787 RD = FieldRecTy->castAs<RecordType>()->getDecl();
8788 } else {
8789 RD = cast<RecordDecl>(Next);
8790 }
8791
8792 // Add a null marker so we know when we've gone back up a level
8793 VisitStack.push_back(nullptr);
8794
8795 for (const auto *FD : RD->fields()) {
8796 QualType QT = FD->getType();
8797
8798 if (ValidTypes.count(QT.getTypePtr()))
8799 continue;
8800
8802 if (ParamType == ValidKernelParam)
8803 continue;
8804
8805 if (ParamType == RecordKernelParam) {
8806 VisitStack.push_back(FD);
8807 continue;
8808 }
8809
8810 // OpenCL v1.2 s6.9.p:
8811 // Arguments to kernel functions that are declared to be a struct or union
8812 // do not allow OpenCL objects to be passed as elements of the struct or
8813 // union.
8814 if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam ||
8815 ParamType == InvalidAddrSpacePtrKernelParam) {
8816 S.Diag(Param->getLocation(),
8817 diag::err_record_with_pointers_kernel_param)
8818 << PT->isUnionType()
8819 << PT;
8820 } else {
8821 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
8822 }
8823
8824 S.Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type)
8825 << OrigRecDecl->getDeclName();
8826
8827 // We have an error, now let's go back up through history and show where
8828 // the offending field came from
8830 I = HistoryStack.begin() + 1,
8831 E = HistoryStack.end();
8832 I != E; ++I) {
8833 const FieldDecl *OuterField = *I;
8834 S.Diag(OuterField->getLocation(), diag::note_within_field_of_type)
8835 << OuterField->getType();
8836 }
8837
8838 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
8839 << QT->isPointerType()
8840 << QT;
8841 D.setInvalidType();
8842 return;
8843 }
8844 } while (!VisitStack.empty());
8845}
8846
8847/// Find the DeclContext in which a tag is implicitly declared if we see an
8848/// elaborated type specifier in the specified context, and lookup finds
8849/// nothing.
8851 while (!DC->isFileContext() && !DC->isFunctionOrMethod())
8852 DC = DC->getParent();
8853 return DC;
8854}
8855
8856/// Find the Scope in which a tag is implicitly declared if we see an
8857/// elaborated type specifier in the specified context, and lookup finds
8858/// nothing.
8859static Scope *getTagInjectionScope(Scope *S, const LangOptions &LangOpts) {
8860 while (S->isClassScope() ||
8861 (LangOpts.CPlusPlus &&
8862 S->isFunctionPrototypeScope()) ||
8863 ((S->getFlags() & Scope::DeclScope) == 0) ||
8864 (S->getEntity() && S->getEntity()->isTransparentContext()))
8865 S = S->getParent();
8866 return S;
8867}
8868
8869NamedDecl*
8872 MultiTemplateParamsArg TemplateParamListsRef,
8873 bool &AddToScope) {
8874 QualType R = TInfo->getType();
8875
8876 assert(R->isFunctionType());
8878 Diag(D.getIdentifierLoc(), diag::err_function_decl_cmse_ns_call);
8879
8880 SmallVector<TemplateParameterList *, 4> TemplateParamLists;
8881 for (TemplateParameterList *TPL : TemplateParamListsRef)
8882 TemplateParamLists.push_back(TPL);
8884 if (!TemplateParamLists.empty() &&
8885 Invented->getDepth() == TemplateParamLists.back()->getDepth())
8886 TemplateParamLists.back() = Invented;
8887 else
8888 TemplateParamLists.push_back(Invented);
8889 }
8890
8891 // TODO: consider using NameInfo for diagnostic.
8893 DeclarationName Name = NameInfo.getName();
8895
8898 diag::err_invalid_thread)
8900
8903 D.getIdentifierLoc());
8904
8905 bool isFriend = false;
8907 bool isMemberSpecialization = false;
8908 bool isFunctionTemplateSpecialization = false;
8909
8910 bool isDependentClassScopeExplicitSpecialization = false;
8911 bool HasExplicitTemplateArgs = false;
8912 TemplateArgumentListInfo TemplateArgs;
8913
8914 bool isVirtualOkay = false;
8915
8916 DeclContext *OriginalDC = DC;
8917 bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC);
8918
8919 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
8920 isVirtualOkay);
8921 if (!NewFD) return nullptr;
8922
8925
8926 // Set the lexical context. If this is a function-scope declaration, or has a
8927 // C++ scope specifier, or is the object of a friend declaration, the lexical
8928 // context will be different from the semantic context.
8930
8931 if (IsLocalExternDecl)
8932 NewFD->setLocalExternDecl();
8933
8934 if (getLangOpts().CPlusPlus) {
8935 bool isInline = D.getDeclSpec().isInlineSpecified();
8936 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
8937 bool hasExplicit = D.getDeclSpec().hasExplicitSpecifier();
8938 isFriend = D.getDeclSpec().isFriendSpecified();
8939 if (isFriend && !isInline && D.isFunctionDefinition()) {
8940 // C++ [class.friend]p5
8941 // A function can be defined in a friend declaration of a
8942 // class . . . . Such a function is implicitly inline.
8943 NewFD->setImplicitlyInline();
8944 }
8945
8946 // If this is a method defined in an __interface, and is not a constructor
8947 // or an overloaded operator, then set the pure flag (isVirtual will already
8948 // return true).
8949 if (const CXXRecordDecl *Parent =
8950 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
8951 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
8952 NewFD->setPure(true);
8953
8954 // C++ [class.union]p2
8955 // A union can have member functions, but not virtual functions.
8956 if (isVirtual && Parent->isUnion())
8957 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union);
8958 }
8959
8960 SetNestedNameSpecifier(*this, NewFD, D);
8961 isMemberSpecialization = false;
8962 isFunctionTemplateSpecialization = false;
8963 if (D.isInvalidType())
8964 NewFD->setInvalidDecl();
8965
8966 // Match up the template parameter lists with the scope specifier, then
8967 // determine whether we have a template or a template specialization.
8968 bool Invalid = false;
8969 TemplateParameterList *TemplateParams =
8972 D.getCXXScopeSpec(),
8974 ? D.getName().TemplateId
8975 : nullptr,
8976 TemplateParamLists, isFriend, isMemberSpecialization,
8977 Invalid);
8978 if (TemplateParams) {
8979 // Check that we can declare a template here.
8980 if (CheckTemplateDeclScope(S, TemplateParams))
8981 NewFD->setInvalidDecl();
8982
8983 if (TemplateParams->size() > 0) {
8984 // This is a function template
8985
8986 // A destructor cannot be a template.
8987 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
8988 Diag(NewFD->getLocation(), diag::err_destructor_template);
8989 NewFD->setInvalidDecl();
8990 }
8991
8992 // If we're adding a template to a dependent context, we may need to
8993 // rebuilding some of the types used within the template parameter list,
8994 // now that we know what the current instantiation is.
8995 if (DC->isDependentContext()) {
8996 ContextRAII SavedContext(*this, DC);
8998 Invalid = true;
8999 }
9000
9002 NewFD->getLocation(),
9003 Name, TemplateParams,
9004 NewFD);
9005 FunctionTemplate->setLexicalDeclContext(CurContext);
9007
9008 // For source fidelity, store the other template param lists.
9009 if (TemplateParamLists.size() > 1) {
9011 ArrayRef<TemplateParameterList *>(TemplateParamLists)
9012 .drop_back(1));
9013 }
9014 } else {
9015 // This is a function template specialization.
9016 isFunctionTemplateSpecialization = true;
9017 // For source fidelity, store all the template param lists.
9018 if (TemplateParamLists.size() > 0)
9019 NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
9020
9021 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
9022 if (isFriend) {
9023 // We want to remove the "template<>", found here.
9024 SourceRange RemoveRange = TemplateParams->getSourceRange();
9025
9026 // If we remove the template<> and the name is not a
9027 // template-id, we're actually silently creating a problem:
9028 // the friend declaration will refer to an untemplated decl,
9029 // and clearly the user wants a template specialization. So
9030 // we need to insert '<>' after the name.
9031 SourceLocation InsertLoc;
9033 InsertLoc = D.getName().getSourceRange().getEnd();
9034 InsertLoc = getLocForEndOfToken(InsertLoc);
9035 }
9036
9037 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
9038 << Name << RemoveRange
9039 << FixItHint::CreateRemoval(RemoveRange)
9040 << FixItHint::CreateInsertion(InsertLoc, "<>");
9041 }
9042 }
9043 } else {
9044 // Check that we can declare a template here.
9045 if (!TemplateParamLists.empty() && isMemberSpecialization &&
9046 CheckTemplateDeclScope(S, TemplateParamLists.back()))
9047 NewFD->setInvalidDecl();
9048
9049 // All template param lists were matched against the scope specifier:
9050 // this is NOT (an explicit specialization of) a template.
9051 if (TemplateParamLists.size() > 0)
9052 // For source fidelity, store all the template param lists.
9053 NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
9054 }
9055
9056 if (Invalid) {
9057 NewFD->setInvalidDecl();
9058 if (FunctionTemplate)
9059 FunctionTemplate->setInvalidDecl();
9060 }
9061
9062 // C++ [dcl.fct.spec]p5:
9063 // The virtual specifier shall only be used in declarations of
9064 // nonstatic class member functions that appear within a
9065 // member-specification of a class declaration; see 10.3.
9066 //
9067 if (isVirtual && !NewFD->isInvalidDecl()) {
9068 if (!isVirtualOkay) {
9070 diag::err_virtual_non_function);
9071 } else if (!CurContext->isRecord()) {
9072 // 'virtual' was specified outside of the class.
9074 diag::err_virtual_out_of_class)
9076 } else if (NewFD->getDescribedFunctionTemplate()) {
9077 // C++ [temp.mem]p3:
9078 // A member function template shall not be virtual.
9080 diag::err_virtual_member_function_template)
9082 } else {
9083 // Okay: Add virtual to the method.
9084 NewFD->setVirtualAsWritten(true);
9085 }
9086
9087 if (getLangOpts().CPlusPlus14 &&
9088 NewFD->getReturnType()->isUndeducedType())
9089 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
9090 }
9091
9092 if (getLangOpts().CPlusPlus14 &&
9093 (NewFD->isDependentContext() ||
9094 (isFriend && CurContext->isDependentContext())) &&
9095 NewFD->getReturnType()->isUndeducedType()) {
9096 // If the function template is referenced directly (for instance, as a
9097 // member of the current instantiation), pretend it has a dependent type.
9098 // This is not really justified by the standard, but is the only sane
9099 // thing to do.
9100 // FIXME: For a friend function, we have not marked the function as being
9101 // a friend yet, so 'isDependentContext' on the FD doesn't work.
9102 const FunctionProtoType *FPT =
9103 NewFD->getType()->castAs<FunctionProtoType>();
9107 FPT->getExtProtoInfo()));
9108 }
9109
9110 // C++ [dcl.fct.spec]p3:
9111 // The inline specifier shall not appear on a block scope function
9112 // declaration.
9113 if (isInline && !NewFD->isInvalidDecl()) {
9115 // 'inline' is not allowed on block scope function declaration.
9117 diag::err_inline_declaration_block_scope) << Name
9119 }
9120 }
9121
9122 // C++ [dcl.fct.spec]p6:
9123 // The explicit specifier shall be used only in the declaration of a
9124 // constructor or conversion function within its class definition;
9125 // see 12.3.1 and 12.3.2.
9126 if (hasExplicit && !NewFD->isInvalidDecl() &&
9127 !isa<CXXDeductionGuideDecl>(NewFD)) {
9128 if (!CurContext->isRecord()) {
9129 // 'explicit' was specified outside of the class.
9131 diag::err_explicit_out_of_class)
9133 } else if (!isa<CXXConstructorDecl>(NewFD) &&
9134 !isa<CXXConversionDecl>(NewFD)) {
9135 // 'explicit' was specified on a function that wasn't a constructor
9136 // or conversion function.
9138 diag::err_explicit_non_ctor_or_conv_function)
9140 }
9141 }
9142
9144 if (ConstexprKind != ConstexprSpecKind::Unspecified) {
9145 // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
9146 // are implicitly inline.
9147 NewFD->setImplicitlyInline();
9148
9149 // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
9150 // be either constructors or to return a literal type. Therefore,
9151 // destructors cannot be declared constexpr.
9152 if (isa<CXXDestructorDecl>(NewFD) &&
9154 ConstexprKind == ConstexprSpecKind::Consteval)) {
9155 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor)
9156 << static_cast<int>(ConstexprKind);
9160 }
9161 // C++20 [dcl.constexpr]p2: An allocation function, or a
9162 // deallocation function shall not be declared with the consteval
9163 // specifier.
9164 if (ConstexprKind == ConstexprSpecKind::Consteval &&
9165 (NewFD->getOverloadedOperator() == OO_New ||
9166 NewFD->getOverloadedOperator() == OO_Array_New ||
9167 NewFD->getOverloadedOperator() == OO_Delete ||
9168 NewFD->getOverloadedOperator() == OO_Array_Delete)) {
9170 diag::err_invalid_consteval_decl_kind)
9171 << NewFD;
9173 }
9174 }
9175
9176 // If __module_private__ was specified, mark the function accordingly.
9178 if (isFunctionTemplateSpecialization) {
9179 SourceLocation ModulePrivateLoc
9181 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
9182 << 0
9183 << FixItHint::CreateRemoval(ModulePrivateLoc);
9184 } else {
9185 NewFD->setModulePrivate();
9186 if (FunctionTemplate)
9187 FunctionTemplate->setModulePrivate();
9188 }
9189 }
9190
9191 if (isFriend) {
9192 if (FunctionTemplate) {
9193 FunctionTemplate->setObjectOfFriendDecl();
9194 FunctionTemplate->setAccess(AS_public);
9195 }
9196 NewFD->setObjectOfFriendDecl();
9197 NewFD->setAccess(AS_public);
9198 }
9199
9200 // If a function is defined as defaulted or deleted, mark it as such now.
9201 // We'll do the relevant checks on defaulted / deleted functions later.
9202 switch (D.getFunctionDefinitionKind()) {
9205 break;
9206
9208 NewFD->setDefaulted();
9209 break;
9210
9212 NewFD->setDeletedAsWritten();
9213 break;
9214 }
9215
9216 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
9218 // C++ [class.mfct]p2:
9219 // A member function may be defined (8.4) in its class definition, in
9220 // which case it is an inline member function (7.1.2)
9221 NewFD->setImplicitlyInline();
9222 }
9223
9224 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
9225 !CurContext->isRecord()) {
9226 // C++ [class.static]p1:
9227 // A data or function member of a class may be declared static
9228 // in a class definition, in which case it is a static member of
9229 // the class.
9230
9231 // Complain about the 'static' specifier if it's on an out-of-line
9232 // member function definition.
9233
9234 // MSVC permits the use of a 'static' storage specifier on an out-of-line
9235 // member function template declaration and class member template
9236 // declaration (MSVC versions before 2015), warn about this.
9238 ((!getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
9239 cast<CXXRecordDecl>(DC)->getDescribedClassTemplate()) ||
9240 (getLangOpts().MSVCCompat && NewFD->getDescribedFunctionTemplate()))
9241 ? diag::ext_static_out_of_line : diag::err_static_out_of_line)
9243 }
9244
9245 // C++11 [except.spec]p15:
9246 // A deallocation function with no exception-specification is treated
9247 // as if it were specified with noexcept(true).
9248 const FunctionProtoType *FPT = R->getAs<FunctionProtoType>();
9249 if ((Name.getCXXOverloadedOperator() == OO_Delete ||
9250 Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
9251 getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec())
9253 FPT->getReturnType(), FPT->getParamTypes(),
9255 }
9256
9257 // Filter out previous declarations that don't match the scope.
9260 isMemberSpecialization ||
9261 isFunctionTemplateSpecialization);
9262
9263 // Handle GNU asm-label extension (encoded as an attribute).
9264 if (Expr *E = (Expr*) D.getAsmLabel()) {
9265 // The parser guarantees this is a string.
9268 /*IsLiteralLabel=*/true,
9269 SE->getStrTokenLoc(0)));
9270 } else if (!ExtnameUndeclaredIdentifiers.empty()) {
9271 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
9273 if (I != ExtnameUndeclaredIdentifiers.end()) {
9274 if (isDeclExternC(NewFD)) {
9275 NewFD->addAttr(I->second);
9277 } else
9278 Diag(NewFD->getLocation(), diag::warn_redefine_extname_not_applied)
9279 << /*Variable*/0 << NewFD;
9280 }
9281 }
9282
9283 // Copy the parameter declarations from the declarator D to the function
9284 // declaration NewFD, if they are available. First scavenge them into Params.
9286 unsigned FTIIdx;
9287 if (D.isFunctionDeclarator(FTIIdx)) {
9289
9290 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
9291 // function that takes no arguments, not a function that takes a
9292 // single void argument.
9293 // We let through "const void" here because Sema::GetTypeForDeclarator
9294 // already checks for that case.
9295 if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) {
9296 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
9297 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
9298 assert(Param->getDeclContext() != NewFD && "Was set before ?");
9299 Param->setDeclContext(NewFD);
9300 Params.push_back(Param);
9301
9302 if (Param->isInvalidDecl())
9303 NewFD->setInvalidDecl();
9304 }
9305 }
9306
9307 if (!getLangOpts().CPlusPlus) {
9308 // In C, find all the tag declarations from the prototype and move them
9309 // into the function DeclContext. Remove them from the surrounding tag
9310 // injection context of the function, which is typically but not always
9311 // the TU.
9312 DeclContext *PrototypeTagContext =
9314 for (NamedDecl *NonParmDecl : FTI.getDeclsInPrototype()) {
9315 auto *TD = dyn_cast<TagDecl>(NonParmDecl);
9316
9317 // We don't want to reparent enumerators. Look at their parent enum
9318 // instead.
9319 if (!TD) {
9320 if (auto *ECD = dyn_cast<EnumConstantDecl>(NonParmDecl))
9321 TD = cast<EnumDecl>(ECD->getDeclContext());
9322 }
9323 if (!TD)
9324 continue;
9325 DeclContext *TagDC = TD->getLexicalDeclContext();
9326 if (!TagDC->containsDecl(TD))
9327 continue;
9328 TagDC->removeDecl(TD);
9329 TD->setDeclContext(NewFD);
9330 NewFD->addDecl(TD);
9331
9332 // Preserve the lexical DeclContext if it is not the surrounding tag
9333 // injection context of the FD. In this example, the semantic context of
9334 // E will be f and the lexical context will be S, while both the
9335 // semantic and lexical contexts of S will be f:
9336 // void f(struct S { enum E { a } f; } s);
9337 if (TagDC != PrototypeTagContext)
9338 TD->setLexicalDeclContext(TagDC);
9339 }
9340 }
9341 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
9342 // When we're declaring a function with a typedef, typeof, etc as in the
9343 // following example, we'll need to synthesize (unnamed)
9344 // parameters for use in the declaration.
9345 //
9346 // @code
9347 // typedef void fn(int);
9348 // fn f;
9349 // @endcode
9350
9351 // Synthesize a parameter for each argument type.
9352 for (const auto &AI : FT->param_types()) {
9353 ParmVarDecl *Param =
9355 Param->setScopeInfo(0, Params.size());
9356 Params.push_back(Param);
9357 }
9358 } else {
9359 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
9360 "Should not need args for typedef of non-prototype fn");
9361 }
9362
9363 // Finally, we know we have the right number of parameters, install them.
9364 NewFD->setParams(Params);
9365
9370
9371 // Functions returning a variably modified type violate C99 6.7.5.2p2
9372 // because all functions have linkage.
9373 if (!NewFD->isInvalidDecl() &&
9375 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
9376 NewFD->setInvalidDecl();
9377 }
9378
9379 // Apply an implicit SectionAttr if '#pragma clang section text' is active
9381 !NewFD->hasAttr<SectionAttr>())
9385
9386 // Apply an implicit SectionAttr if #pragma code_seg is active.
9387 if (CodeSegStack.CurrentValue && D.isFunctionDefinition() &&
9388 !NewFD->hasAttr<SectionAttr>()) {
9390 Context, CodeSegStack.CurrentValue->getString(),
9391 CodeSegStack.CurrentPragmaLocation, AttributeCommonInfo::AS_Pragma,
9393 if (UnifySection(CodeSegStack.CurrentValue->getString(),
9396 NewFD))
9397 NewFD->dropAttr<SectionAttr>();
9398 }
9399
9400 // Apply an implicit CodeSegAttr from class declspec or
9401 // apply an implicit SectionAttr from #pragma code_seg if active.
9402 if (!NewFD->hasAttr<CodeSegAttr>()) {
9404 D.isFunctionDefinition())) {
9405 NewFD->addAttr(SAttr);
9406 }
9407 }
9408
9409 // Handle attributes.
9410 ProcessDeclAttributes(S, NewFD, D);
9411
9412 if (getLangOpts().OpenCL) {
9413 // OpenCL v1.1 s6.5: Using an address space qualifier in a function return
9414 // type declaration will generate a compilation error.
9415 LangAS AddressSpace = NewFD->getReturnType().getAddressSpace();
9416 if (AddressSpace != LangAS::Default) {
9417 Diag(NewFD->getLocation(),
9418 diag::err_opencl_return_value_with_address_space);
9419 NewFD->setInvalidDecl();
9420 }
9421 }
9422
9423 if (LangOpts.SYCLIsDevice || (LangOpts.OpenMP && LangOpts.OpenMPIsDevice))
9424 checkDeviceDecl(NewFD, D.getBeginLoc());
9425
9426 if (!getLangOpts().CPlusPlus) {
9427 // Perform semantic checking on the function declaration.
9428 if (!NewFD->isInvalidDecl() && NewFD->isMain())
9429 CheckMain(NewFD, D.getDeclSpec());
9430
9431 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
9432 CheckMSVCRTEntryPoint(NewFD);
9433
9434 if (!NewFD->isInvalidDecl())
9436 isMemberSpecialization));
9437 else if (!Previous.empty())
9438 // Recover gracefully from an invalid redeclaration.
9439 D.setRedeclaration(true);
9440 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
9441 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
9442 "previous declaration set still overloaded");
9443
9444 // Diagnose no-prototype function declarations with calling conventions that
9445 // don't support variadic calls. Only do this in C and do it after merging
9446 // possibly prototyped redeclarations.
9447 const FunctionType *FT = NewFD->getType()->castAs<FunctionType>();
9448 if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) {
9449 CallingConv CC = FT->getExtInfo().getCC();
9450 if (!supportsVariadicCall(CC)) {
9451 // Windows system headers sometimes accidentally use stdcall without
9452 // (void) parameters, so we relax this to a warning.
9453 int DiagID =
9454 CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
9455 Diag(NewFD->getLocation(), DiagID)
9457 }
9458 }
9459
9465 } else {
9466 // C++11 [replacement.functions]p3:
9467 // The program's definitions shall not be specified as inline.
9468 //
9469 // N.B. We diagnose declarations instead of definitions per LWG issue 2340.
9470 //
9471 // Suppress the diagnostic if the function is __attribute__((used)), since
9472 // that forces an external definition to be emitted.
9473 if (D.getDeclSpec().isInlineSpecified() &&
9475 !NewFD->hasAttr<UsedAttr>())
9477 diag::ext_operator_new_delete_declared_inline)
9478 << NewFD->getDeclName();
9479
9480 // If the declarator is a template-id, translate the parser's template
9481 // argument list into our AST format.
9483 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
9484 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
9485 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
9486 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
9487 TemplateId->NumArgs);
9488 translateTemplateArguments(TemplateArgsPtr,
9489 TemplateArgs);
9490
9491 HasExplicitTemplateArgs = true;
9492
9493 if (NewFD->isInvalidDecl()) {
9494 HasExplicitTemplateArgs = false;
9495 } else if (FunctionTemplate) {
9496 // Function template with explicit template arguments.
9497 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
9498 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
9499
9500 HasExplicitTemplateArgs = false;
9501 } else {
9502 assert((isFunctionTemplateSpecialization ||
9504 "should have a 'template<>' for this decl");
9505 // "friend void foo<>(int);" is an implicit specialization decl.
9506 isFunctionTemplateSpecialization = true;
9507 }
9508 } else if (isFriend && isFunctionTemplateSpecialization) {
9509 // This combination is only possible in a recovery case; the user
9510 // wrote something like:
9511 // template <> friend void foo(int);
9512 // which we're recovering from as if the user had written:
9513 // friend void foo<>(int);
9514 // Go ahead and fake up a template id.
9515 HasExplicitTemplateArgs = true;
9516 TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
9517 TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
9518 }
9519
9520 // We do not add HD attributes to specializations here because
9521 // they may have different constexpr-ness compared to their
9522 // templates and, after maybeAddCUDAHostDeviceAttrs() is applied,
9523 // may end up with different effective targets. Instead, a
9524 // specialization inherits its target attributes from its template
9525 // in the CheckFunctionTemplateSpecialization() call below.
9526 if (getLangOpts().CUDA && !isFunctionTemplateSpecialization)
9528
9529 // If it's a friend (and only if it's a friend), it's possible
9530 // that either the specialized function type or the specialized
9531 // template is dependent, and therefore matching will fail. In
9532 // this case, don't check the specialization yet.
9533 if (isFunctionTemplateSpecialization && isFriend &&
9534 (NewFD->getType()->isDependentType() || DC->isDependentContext() ||
9536 TemplateArgs.arguments()))) {
9537 assert(HasExplicitTemplateArgs &&
9538 "friend function specialization without template args");
9539 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
9540 Previous))
9541 NewFD->setInvalidDecl();
9542 } else if (isFunctionTemplateSpecialization) {
9544 && !isFriend) {
9545 isDependentClassScopeExplicitSpecialization = true;
9546 } else if (!NewFD->isInvalidDecl() &&
9548 NewFD, (HasExplicitTemplateArgs ? &TemplateArgs : nullptr),
9549 Previous))
9550 NewFD->setInvalidDecl();
9551
9552 // C++ [dcl.stc]p1:
9553 // A storage-class-specifier shall not be specified in an explicit
9554 // specialization (14.7.3)
9557 if (Info && SC != SC_None) {
9558 if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass())
9559 Diag(NewFD->getLocation(),
9560 diag::err_explicit_specialization_inconsistent_storage_class)
9561 << SC
9564
9565 else
9566 Diag(NewFD->getLocation(),
9567 diag::ext_explicit_specialization_storage_class)
9570 }
9571 } else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) {
9573 NewFD->setInvalidDecl();
9574 }
9575
9576 // Perform semantic checking on the function declaration.
9577 if (!isDependentClassScopeExplicitSpecialization) {
9578 if (!NewFD->isInvalidDecl() && NewFD->isMain())
9579 CheckMain(NewFD, D.getDeclSpec());
9580
9581 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
9582 CheckMSVCRTEntryPoint(NewFD);
9583
9584 if (!NewFD->isInvalidDecl())
9586 isMemberSpecialization));
9587 else if (!Previous.empty())
9588 // Recover gracefully from an invalid redeclaration.
9589 D.setRedeclaration(true);
9590 }
9591
9592 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
9593 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
9594 "previous declaration set still overloaded");
9595
9596 NamedDecl *PrincipalDecl = (FunctionTemplate
9598 : NewFD);
9599
9600 if (isFriend && NewFD->getPreviousDecl()) {
9601 AccessSpecifier Access = AS_public;
9602 if (!NewFD->isInvalidDecl())
9603 Access = NewFD->getPreviousDecl()->getAccess();
9604
9605 NewFD->setAccess(Access);
9606 if (FunctionTemplate) FunctionTemplate->setAccess(Access);
9607 }
9608
9609 if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
9611 PrincipalDecl->setNonMemberOperator();
9612
9613 // If we have a function template, check the template parameter
9614 // list. This will check and merge default template arguments.
9615 if (FunctionTemplate) {
9616 FunctionTemplateDecl *PrevTemplate =
9618 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
9619 PrevTemplate ? PrevTemplate->getTemplateParameters()
9620 : nullptr,
9625 : (D.getCXXScopeSpec().isSet() &&
9626 DC && DC->isRecord() &&
9627 DC->isDependentContext())
9630 }
9631
9632 if (NewFD->isInvalidDecl()) {
9633 // Ignore all the rest of this.
9634 } else if (!D.isRedeclaration()) {
9635 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
9636 AddToScope };
9637 // Fake up an access specifier if it's supposed to be a class member.
9638 if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
9639 NewFD->setAccess(AS_public);
9640
9641 // Qualified decls generally require a previous declaration.
9642 if (D.getCXXScopeSpec().isSet()) {
9643 // ...with the major exception of templated-scope or
9644 // dependent-scope friend declarations.
9645
9646 // TODO: we currently also suppress this check in dependent
9647 // contexts because (1) the parameter depth will be off when
9648 // matching friend templates and (2) we might actually be
9649 // selecting a friend based on a dependent factor. But there
9650 // are situations where these conditions don't apply and we
9651 // can actually do this check immediately.
9652 //
9653 // Unless the scope is dependent, it's always an error if qualified
9654 // redeclaration lookup found nothing at all. Diagnose that now;
9655 // nothing will diagnose that error later.
9656 if (isFriend &&
9658 (!Previous.empty() && CurContext->isDependentContext()))) {
9659 // ignore these
9660 } else {
9661 // The user tried to provide an out-of-line definition for a
9662 // function that is a member of a class or namespace, but there
9663 // was no such member function declared (C++ [class.mfct]p2,
9664 // C++ [namespace.memdef]p2). For example:
9665 //
9666 // class X {
9667 // void f() const;
9668 // };
9669 //
9670 // void X::f() { } // ill-formed
9671 //
9672 // Complain about this problem, and attempt to suggest close
9673 // matches (e.g., those that differ only in cv-qualifiers and
9674 // whether the parameter types are references).
9675
9677 *this, Previous, NewFD, ExtraArgs, false, nullptr)) {
9678 AddToScope = ExtraArgs.AddToScope;
9679 return Result;
9680 }
9681 }
9682
9683 // Unqualified local friend declarations are required to resolve
9684 // to something.
9685 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
9687 *this, Previous, NewFD, ExtraArgs, true, S)) {
9688 AddToScope = ExtraArgs.AddToScope;
9689 return Result;
9690 }
9691 }
9692 } else if (!D.isFunctionDefinition() &&
9693 isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
9694 !isFriend && !isFunctionTemplateSpecialization &&
9695 !isMemberSpecialization) {
9696 // An out-of-line member function declaration must also be a
9697 // definition (C++ [class.mfct]p2).
9698 // Note that this is not the case for explicit specializations of
9699 // function templates or member functions of class templates, per
9700 // C++ [temp.expl.spec]p2. We also allow these declarations as an
9701 // extension for compatibility with old SWIG code which likes to
9702 // generate them.
9703 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
9704 << D.getCXXScopeSpec().getRange();
9705 }
9706 }
9707
9708 // If this is the first declaration of a library builtin function, add
9709 // attributes as appropriate.
9710 if (!D.isRedeclaration() &&
9712 if (IdentifierInfo *II = Previous.getLookupName().getAsIdentifierInfo()) {
9713 if (unsigned BuiltinID = II->getBuiltinID()) {
9714 if (NewFD->getLanguageLinkage() == CLanguageLinkage) {
9715 // Validate the type matches unless this builtin is specified as
9716 // matching regardless of its declared type.
9717 if (Context.BuiltinInfo.allowTypeMismatch(BuiltinID)) {
9718 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID));
9719 } else {
9721 LookupNecessaryTypesForBuiltin(S, BuiltinID);
9722 QualType BuiltinType = Context.GetBuiltinType(BuiltinID, Error);
9723
9724 if (!Error && !BuiltinType.isNull() &&
9726 NewFD->getType(), BuiltinType))
9727 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID));
9728 }
9729 } else if (BuiltinID == Builtin::BI__GetExceptionInfo &&
9731 // FIXME: We should consider this a builtin only in the std namespace.
9732 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID));
9733 }
9734 }
9735 }
9736 }
9737
9738 ProcessPragmaWeak(S, NewFD);
9739 checkAttributesAfterMerging(*this, *NewFD);
9740
9742
9743 if (NewFD->hasAttr<OverloadableAttr>() &&
9744 !NewFD->getType()->getAs<FunctionProtoType>()) {
9745 Diag(NewFD->getLocation(),
9746 diag::err_attribute_overloadable_no_prototype)
9747 << NewFD;
9748
9749 // Turn this into a variadic function with no parameters.
9750 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
9753 EPI.Variadic = true;
9754 EPI.ExtInfo = FT->getExtInfo();
9755
9756 QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI);
9757 NewFD->setType(R);
9758 }
9759
9760 // If there's a #pragma GCC visibility in scope, and this isn't a class
9761 // member, set the visibility of this function.
9762 if (!DC->isRecord() && NewFD->isExternallyVisible())
9764
9765 // If there's a #pragma clang arc_cf_code_audited in scope, consider
9766 // marking the function.
9767 AddCFAuditedAttribute(NewFD);
9768
9769 // If this is a function definition, check if we have to apply optnone due to
9770 // a pragma.
9771 if(D.isFunctionDefinition())
9772 AddRangeBasedOptnone(NewFD);
9773
9774 // If this is the first declaration of an extern C variable, update
9775 // the map of such variables.
9776 if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
9777 isIncompleteDeclExternC(*this, NewFD))
9779
9780 // Set this FunctionDecl's range up to the right paren.
9781 NewFD->setRangeEnd(D.getSourceRange().getEnd());
9782
9783 if (D.isRedeclaration() && !Previous.empty()) {
9784 NamedDecl *Prev = Previous.getRepresentativeDecl();
9785 checkDLLAttributeRedeclaration(*this, Prev, NewFD,
9786 isMemberSpecialization ||
9787 isFunctionTemplateSpecialization,
9789 }
9790
9791 if (getLangOpts().CUDA) {
9792 IdentifierInfo *II = NewFD->getIdentifier();
9793 if (II && II->isStr(getCudaConfigureFuncName()) &&
9794 !NewFD->isInvalidDecl() &&
9797 Diag(NewFD->getLocation(), diag::err_config_scalar_return)
9800 }
9801
9802 // Variadic functions, other than a *declaration* of printf, are not allowed
9803 // in device-side CUDA code, unless someone passed
9804 // -fcuda-allow-variadic-functions.
9805 if (!getLangOpts().CUDAAllowVariadicFunctions && NewFD->isVariadic() &&
9806 (NewFD->hasAttr<CUDADeviceAttr>() ||
9807 NewFD->hasAttr<CUDAGlobalAttr>()) &&
9808 !(II && II->isStr("printf") && NewFD->isExternC() &&
9809 !D.isFunctionDefinition())) {
9810 Diag(NewFD->getLocation(), diag::err_variadic_device_fn);
9811 }
9812 }
9813
9815
9816
9817
9818 if (getLangOpts().OpenCL && NewFD->hasAttr<OpenCLKernelAttr>()) {
9819 // OpenCL v1.2 s6.8 static is invalid for kernel functions.
9820 if ((getLangOpts().OpenCLVersion >= 120)
9821 && (SC == SC_Static)) {
9822 Diag(D.getIdentifierLoc(), diag::err_static_kernel);
9823 D.setInvalidType();
9824 }
9825
9826 // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
9827 if (!NewFD->getReturnType()->isVoidType()) {
9828 SourceRange RTRange = NewFD->getReturnTypeSourceRange();
9829 Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
9830 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
9831 : FixItHint());
9832 D.setInvalidType();
9833 }
9834
9836 for (auto Param : NewFD->parameters())
9837 checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
9838
9839 if (getLangOpts().OpenCLCPlusPlus) {
9840 if (DC->isRecord()) {
9841 Diag(D.getIdentifierLoc(), diag::err_method_kernel);
9842 D.setInvalidType();
9843 }
9844 if (FunctionTemplate) {
9845 Diag(D.getIdentifierLoc(), diag::err_template_kernel);
9846 D.setInvalidType();
9847 }
9848 }
9849 }
9850
9851 if (getLangOpts().CPlusPlus) {
9852 if (FunctionTemplate) {
9853 if (NewFD->isInvalidDecl())
9854 FunctionTemplate->setInvalidDecl();
9855 return FunctionTemplate;
9856 }
9857
9858 if (isMemberSpecialization && !NewFD->isInvalidDecl())
9860 }
9861
9862 for (const ParmVarDecl *Param : NewFD->parameters()) {
9863 QualType PT = Param->getType();
9864
9865 // OpenCL 2.0 pipe restrictions forbids pipe packet types to be non-value
9866 // types.
9867 if (getLangOpts().OpenCLVersion >= 200 || getLangOpts().OpenCLCPlusPlus) {
9868 if(const PipeType *PipeTy = PT->getAs<PipeType>()) {
9869 QualType ElemTy = PipeTy->getElementType();
9870 if (ElemTy->isReferenceType() || ElemTy->isPointerType()) {
9871 Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type );
9872 D.setInvalidType();
9873 }
9874 }
9875 }
9876 }
9877
9878 // Here we have an function template explicit specialization at class scope.
9879 // The actual specialization will be postponed to template instatiation
9880 // time via the ClassScopeFunctionSpecializationDecl node.
9881 if (isDependentClassScopeExplicitSpecialization) {
9884 Context, CurContext, NewFD->getLocation(),
9885 cast<CXXMethodDecl>(NewFD),
9886 HasExplicitTemplateArgs, TemplateArgs);
9887 CurContext->addDecl(NewSpec);
9888 AddToScope = false;
9889 }
9890
9891 // Diagnose availability attributes. Availability cannot be used on functions
9892 // that are run during load/unload.
9893 if (const auto *attr = NewFD->getAttr<AvailabilityAttr>()) {
9894 if (NewFD->hasAttr<ConstructorAttr>()) {
9895 Diag(attr->getLocation(), diag::warn_availability_on_static_initializer)
9896 << 1;
9897 NewFD->dropAttr<AvailabilityAttr>();
9898 }
9899 if (NewFD->hasAttr<DestructorAttr>()) {
9900 Diag(attr->getLocation(), diag::warn_availability_on_static_initializer)
9901 << 2;
9902 NewFD->dropAttr<AvailabilityAttr>();
9903 }
9904 }
9905
9906 // Diagnose no_builtin attribute on function declaration that are not a
9907 // definition.
9908 // FIXME: We should really be doing this in
9909 // SemaDeclAttr.cpp::handleNoBuiltinAttr, unfortunately we only have access to
9910 // the FunctionDecl and at this point of the code
9911 // FunctionDecl::isThisDeclarationADefinition() which always returns `false`
9912 // because Sema::ActOnStartOfFunctionDef has not been called yet.
9913 if (const auto *NBA = NewFD->getAttr<NoBuiltinAttr>())
9914 switch (D.getFunctionDefinitionKind()) {
9917 Diag(NBA->getLocation(),
9918 diag::err_attribute_no_builtin_on_defaulted_deleted_function)
9919 << NBA->getSpelling();
9920 break;
9922 Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition)
9923 << NBA->getSpelling();
9924 break;
9926 break;
9927 }
9928
9929 return NewFD;
9930}
9931
9932/// Return a CodeSegAttr from a containing class. The Microsoft docs say
9933/// when __declspec(code_seg) "is applied to a class, all member functions of
9934/// the class and nested classes -- this includes compiler-generated special
9935/// member functions -- are put in the specified segment."
9936/// The actual behavior is a little more complicated. The Microsoft compiler
9937/// won't check outer classes if there is an active value from #pragma code_seg.
9938/// The CodeSeg is always applied from the direct parent but only from outer
9939/// classes when the #pragma code_seg stack is empty. See:
9940/// https://reviews.llvm.org/D22931, the Microsoft feedback page is no longer
9941/// available since MS has removed the page.
9943 const auto *Method = dyn_cast<CXXMethodDecl>(FD);
9944 if (!Method)
9945 return nullptr;
9946 const CXXRecordDecl *Parent = Method->getParent();
9947 if (const auto *SAttr = Parent->getAttr<CodeSegAttr>()) {
9948 Attr *NewAttr = SAttr->clone(S.getASTContext());
9949 NewAttr->setImplicit(true);
9950 return NewAttr;
9951 }
9952
9953 // The Microsoft compiler won't check outer classes for the CodeSeg
9954 // when the #pragma code_seg stack is active.
9955 if (S.CodeSegStack.CurrentValue)
9956 return nullptr;
9957
9958 while ((Parent = dyn_cast<CXXRecordDecl>(Parent->getParent()))) {
9959 if (const auto *SAttr = Parent->getAttr<CodeSegAttr>()) {
9960 Attr *NewAttr = SAttr->clone(S.getASTContext());
9961 NewAttr->setImplicit(true);
9962 return NewAttr;
9963 }
9964 }
9965 return nullptr;
9966}
9967
9968/// Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a
9969/// containing class. Otherwise it will return implicit SectionAttr if the
9970/// function is a definition and there is an active value on CodeSegStack
9971/// (from the current #pragma code-seg value).
9972///
9973/// \param FD Function being declared.
9974/// \param IsDefinition Whether it is a definition or just a declarartion.
9975/// \returns A CodeSegAttr or SectionAttr to apply to the function or
9976/// nullptr if no attribute should be added.
9978 bool IsDefinition) {
9979 if (Attr *A = getImplicitCodeSegAttrFromClass(*this, FD))
9980 return A;
9981 if (!FD->hasAttr<SectionAttr>() && IsDefinition &&
9982 CodeSegStack.CurrentValue)
9984 getASTContext(), CodeSegStack.CurrentValue->getString(),
9985 CodeSegStack.CurrentPragmaLocation, AttributeCommonInfo::AS_Pragma,
9987 return nullptr;
9988}
9989
9990/// Determines if we can perform a correct type check for \p D as a
9991/// redeclaration of \p PrevDecl. If not, we can generally still perform a
9992/// best-effort check.
9993///
9994/// \param NewD The new declaration.
9995/// \param OldD The old declaration.
9996/// \param NewT The portion of the type of the new declaration to check.
9997/// \param OldT The portion of the type of the old declaration to check.
9999 QualType NewT, QualType OldT) {
10001 return true;
10002
10003 // For dependently-typed local extern declarations and friends, we can't
10004 // perform a correct type check in general until instantiation:
10005 //
10006 // int f();
10007 // template<typename T> void g() { T f(); }
10008 //
10009 // (valid if g() is only instantiated with T = int).
10010 if (NewT->isDependentType() &&
10011 (NewD->isLocalExternDecl() || NewD->getFriendObjectKind()))
10012 return false;
10013
10014 // Similarly, if the previous declaration was a dependent local extern
10015 // declaration, we don't really know its type yet.
10016 if (OldT->isDependentType() && OldD->isLocalExternDecl())
10017 return false;
10018
10019 return true;
10020}
10021
10022/// Checks if the new declaration declared in dependent context must be
10023/// put in the same redeclaration chain as the specified declaration.
10024///
10025/// \param D Declaration that is checked.
10026/// \param PrevDecl Previous declaration found with proper lookup method for the
10027/// same declaration name.
10028/// \returns True if D must be added to the redeclaration chain which PrevDecl
10029/// belongs to.
10030///
10033 return true;
10034
10035 // Don't chain dependent friend function definitions until instantiation, to
10036 // permit cases like
10037 //
10038 // void func();
10039 // template<typename T> class C1 { friend void func() {} };
10040 // template<typename T> class C2 { friend void func() {} };
10041 //
10042 // ... which is valid if only one of C1 and C2 is ever instantiated.
10043 //
10044 // FIXME: This need only apply to function definitions. For now, we proxy
10045 // this by checking for a file-scope function. We do not want this to apply
10046 // to friend declarations nominating member functions, because that gets in
10047 // the way of access checks.
10049 return false;
10050
10051 auto *VD = dyn_cast<ValueDecl>(D);
10052 auto *PrevVD = dyn_cast<ValueDecl>(PrevDecl);
10053 return !VD || !PrevVD ||
10054 canFullyTypeCheckRedeclaration(VD, PrevVD, VD->getType(),
10055 PrevVD->getType());
10056}
10057
10058/// Check the target attribute of the function for MultiVersion
10059/// validity.
10060///
10061/// Returns true if there was an error, false otherwise.
10062static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD) {
10063 const auto *TA = FD->getAttr<TargetAttr>();
10064 assert(TA && "MultiVersion Candidate requires a target attribute");
10065 ParsedTargetAttr ParseInfo = TA->parse();
10067 enum ErrType { Feature = 0, Architecture = 1 };
10068
10069 if (!ParseInfo.Architecture.empty() &&
10071 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
10072 << Architecture << ParseInfo.Architecture;
10073 return true;
10074 }
10075
10076 for (const auto &Feat : ParseInfo.Features) {
10077 auto BareFeat = StringRef{Feat}.substr(1);
10078 if (Feat[0] == '-') {
10079 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
10080 << Feature << ("no-" + BareFeat).str();
10081 return true;
10082 }
10083
10084 if (!TargetInfo.validateCpuSupports(BareFeat) ||
10085 !TargetInfo.isValidFeatureName(BareFeat)) {
10086 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
10087 << Feature << BareFeat;
10088 return true;
10089 }
10090 }
10091 return false;
10092}
10093
10094// Provide a white-list of attributes that are allowed to be combined with
10095// multiversion functions.
10097 MultiVersionKind MVType) {
10098 // Note: this list/diagnosis must match the list in
10099 // checkMultiversionAttributesAllSame.
10100 switch (Kind) {
10101 default:
10102 return false;
10103 case attr::Used:
10104 return MVType == MultiVersionKind::Target;
10105 case attr::NonNull:
10106 case attr::NoThrow:
10107 return true;
10108 }
10109}
10110
10112 const FunctionDecl *FD,
10113 const FunctionDecl *CausedFD,
10114 MultiVersionKind MVType) {
10115 bool IsCPUSpecificCPUDispatchMVType =
10118 const auto Diagnose = [FD, CausedFD, IsCPUSpecificCPUDispatchMVType](
10119 Sema &S, const Attr *A) {
10120 S.Diag(FD->getLocation(), diag::err_multiversion_disallowed_other_attr)
10121 << IsCPUSpecificCPUDispatchMVType << A;
10122 if (CausedFD)
10123 S.Diag(CausedFD->getLocation(), diag::note_multiversioning_caused_here);
10124 return true;
10125 };
10126
10127 for (const Attr *A : FD->attrs()) {
10128 switch (A->getKind()) {
10129 case attr::CPUDispatch:
10130 case attr::CPUSpecific:
10131 if (MVType != MultiVersionKind::CPUDispatch &&
10133 return Diagnose(S, A);
10134 break;
10135 case attr::Target:
10136 if (MVType != MultiVersionKind::Target)
10137 return Diagnose(S, A);
10138 break;
10139 default:
10140 if (!AttrCompatibleWithMultiVersion(A->getKind(), MVType))
10141 return Diagnose(S, A);
10142 break;
10143 }
10144 }
10145 return false;
10146}
10147
10149 const FunctionDecl *OldFD, const FunctionDecl *NewFD,
10150 const PartialDiagnostic &NoProtoDiagID,
10151 const PartialDiagnosticAt &NoteCausedDiagIDAt,
10152 const PartialDiagnosticAt &NoSupportDiagIDAt,
10153 const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported,
10154 bool ConstexprSupported, bool CLinkageMayDiffer) {
10155 enum DoesntSupport {
10156 FuncTemplates = 0,
10157 VirtFuncs = 1,
10158 DeducedReturn = 2,
10159 Constructors = 3,
10160 Destructors = 4,
10161 DeletedFuncs = 5,
10162 DefaultedFuncs = 6,
10163 ConstexprFuncs = 7,
10164 ConstevalFuncs = 8,
10165 };
10166 enum Different {
10167 CallingConv = 0,
10168 ReturnType = 1,
10169 ConstexprSpec = 2,
10170 InlineSpec = 3,
10171 StorageClass = 4,
10172 Linkage = 5,
10173 };
10174
10175 if (NoProtoDiagID.getDiagID() != 0 && OldFD &&
10176 !OldFD->getType()->getAs<FunctionProtoType>()) {
10177 Diag(OldFD->getLocation(), NoProtoDiagID);
10178 Diag(NoteCausedDiagIDAt.first, NoteCausedDiagIDAt.second);
10179 return true;
10180 }
10181
10182 if (NoProtoDiagID.getDiagID() != 0 &&
10183 !NewFD->getType()->getAs<FunctionProtoType>())
10184 return Diag(NewFD->getLocation(), NoProtoDiagID);
10185
10186 if (!TemplatesSupported &&
10188 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10189 << FuncTemplates;
10190
10191 if (const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
10192 if (NewCXXFD->isVirtual())
10193 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10194 << VirtFuncs;
10195
10196 if (isa<CXXConstructorDecl>(NewCXXFD))
10197 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10198 << Constructors;
10199
10200 if (isa<CXXDestructorDecl>(NewCXXFD))
10201 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10202 << Destructors;
10203 }
10204
10205 if (NewFD->isDeleted())
10206 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10207 << DeletedFuncs;
10208
10209 if (NewFD->isDefaulted())
10210 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10211 << DefaultedFuncs;
10212
10213 if (!ConstexprSupported && NewFD->isConstexpr())
10214 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10215 << (NewFD->isConsteval() ? ConstevalFuncs : ConstexprFuncs);
10216
10217 QualType NewQType = Context.getCanonicalType(NewFD->getType());
10218 const auto *NewType = cast<FunctionType>(NewQType);
10219 QualType NewReturnType = NewType->getReturnType();
10220
10221 if (NewReturnType->isUndeducedType())
10222 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10223 << DeducedReturn;
10224
10225 // Ensure the return type is identical.
10226 if (OldFD) {
10227 QualType OldQType = Context.getCanonicalType(OldFD->getType());
10228 const auto *OldType = cast<FunctionType>(OldQType);
10229 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
10230 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
10231
10232 if (OldTypeInfo.getCC() != NewTypeInfo.getCC())
10233 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << CallingConv;
10234
10235 QualType OldReturnType = OldType->getReturnType();
10236
10237 if (OldReturnType != NewReturnType)
10238 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ReturnType;
10239
10240 if (OldFD->getConstexprKind() != NewFD->getConstexprKind())
10241 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ConstexprSpec;
10242
10243 if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified())
10244 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << InlineSpec;
10245
10246 if (OldFD->getStorageClass() != NewFD->getStorageClass())
10247 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << StorageClass;
10248
10249 if (!CLinkageMayDiffer && OldFD->isExternC() != NewFD->isExternC())
10250 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << Linkage;
10251
10253 OldFD->getType()->getAs<FunctionProtoType>(), OldFD->getLocation(),
10254 NewFD->getType()->getAs<FunctionProtoType>(), NewFD->getLocation()))
10255 return true;
10256 }
10257 return false;
10258}
10259
10261 const FunctionDecl *NewFD,
10262 bool CausesMV,
10263 MultiVersionKind MVType) {
10265 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
10266 if (OldFD)
10267 S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
10268 return true;
10269 }
10270
10271 bool IsCPUSpecificCPUDispatchMVType =
10274
10275 if (CausesMV && OldFD &&
10276 checkNonMultiVersionCompatAttributes(S, OldFD, NewFD, MVType))
10277 return true;
10278
10279 if (checkNonMultiVersionCompatAttributes(S, NewFD, nullptr, MVType))
10280 return true;
10281
10282 // Only allow transition to MultiVersion if it hasn't been used.
10283 if (OldFD && CausesMV && OldFD->isUsed(false))
10284 return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
10285
10287 OldFD, NewFD, S.PDiag(diag::err_multiversion_noproto),
10289 S.PDiag(diag::note_multiversioning_caused_here)),
10291 S.PDiag(diag::err_multiversion_doesnt_support)
10292 << IsCPUSpecificCPUDispatchMVType),
10294 S.PDiag(diag::err_multiversion_diff)),
10295 /*TemplatesSupported=*/false,
10296 /*ConstexprSupported=*/!IsCPUSpecificCPUDispatchMVType,
10297 /*CLinkageMayDiffer=*/false);
10298}
10299
10300/// Check the validity of a multiversion function declaration that is the
10301/// first of its kind. Also sets the multiversion'ness' of the function itself.
10302///
10303/// This sets NewFD->isInvalidDecl() to true if there was an error.
10304///
10305/// Returns true if there was an error, false otherwise.
10307 MultiVersionKind MVType,
10308 const TargetAttr *TA) {
10309 assert(MVType != MultiVersionKind::None &&
10310 "Function lacks multiversion attribute");
10311
10312 // Target only causes MV if it is default, otherwise this is a normal
10313 // function.
10314 if (MVType == MultiVersionKind::Target && !TA->isDefaultVersion())
10315 return false;
10316
10317 if (MVType == MultiVersionKind::Target && CheckMultiVersionValue(S, FD)) {
10318 FD->setInvalidDecl();
10319 return true;
10320 }
10321
10322 if (CheckMultiVersionAdditionalRules(S, nullptr, FD, true, MVType)) {
10323 FD->setInvalidDecl();
10324 return true;
10325 }
10326
10327 FD->setIsMultiVersion();
10328 return false;
10329}
10330
10332 for (const Decl *D = FD->getPreviousDecl(); D; D = D->getPreviousDecl()) {
10334 return true;
10335 }
10336
10337 return false;
10338}
10339
10341 Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, const TargetAttr *NewTA,
10342 bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious,
10344 const auto *OldTA = OldFD->getAttr<TargetAttr>();
10345 ParsedTargetAttr NewParsed = NewTA->parse();
10346 // Sort order doesn't matter, it just needs to be consistent.
10347 llvm::sort(NewParsed.Features);
10348
10349 // If the old decl is NOT MultiVersioned yet, and we don't cause that
10350 // to change, this is a simple redeclaration.
10351 if (!NewTA->isDefaultVersion() &&
10352 (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr()))
10353 return false;
10354
10355 // Otherwise, this decl causes MultiVersioning.
10357 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
10358 S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
10359 NewFD->setInvalidDecl();
10360 return true;
10361 }
10362
10363 if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD, true,
10365 NewFD->setInvalidDecl();
10366 return true;
10367 }
10368
10369 if (CheckMultiVersionValue(S, NewFD)) {
10370 NewFD->setInvalidDecl();
10371 return true;
10372 }
10373
10374 // If this is 'default', permit the forward declaration.
10375 if (!OldFD->isMultiVersion() && !OldTA && NewTA->isDefaultVersion()) {
10376 Redeclaration = true;
10377 OldDecl = OldFD;
10378 OldFD->setIsMultiVersion();
10379 NewFD->setIsMultiVersion();
10380 return false;
10381 }
10382
10383 if (CheckMultiVersionValue(S, OldFD)) {
10384 S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
10385 NewFD->setInvalidDecl();
10386 return true;
10387 }
10388
10389 ParsedTargetAttr OldParsed = OldTA->parse(std::less<std::string>());
10390
10391 if (OldParsed == NewParsed) {
10392 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
10393 S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
10394 NewFD->setInvalidDecl();
10395 return true;
10396 }
10397
10398 for (const auto *FD : OldFD->redecls()) {
10399 const auto *CurTA = FD->getAttr<TargetAttr>();
10400 // We allow forward declarations before ANY multiversioning attributes, but
10401 // nothing after the fact.
10403 (!CurTA || CurTA->isInherited())) {
10404 S.Diag(FD->getLocation(), diag::err_multiversion_required_in_redecl)
10405 << 0;
10406 S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
10407 NewFD->setInvalidDecl();
10408 return true;
10409 }
10410 }
10411
10412 OldFD->setIsMultiVersion();
10413 NewFD->setIsMultiVersion();
10414 Redeclaration = false;
10415 MergeTypeWithPrevious = false;
10416 OldDecl = nullptr;
10417 Previous.clear();
10418 return false;
10419}
10420
10421/// Check the validity of a new function declaration being added to an existing
10422/// multiversioned declaration collection.
10424 Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD,
10425 MultiVersionKind NewMVType, const TargetAttr *NewTA,
10426 const CPUDispatchAttr *NewCPUDisp, const CPUSpecificAttr *NewCPUSpec,
10427 bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious,
10429
10430 MultiVersionKind OldMVType = OldFD->getMultiVersionKind();
10431 // Disallow mixing of multiversioning types.
10432 if ((OldMVType == MultiVersionKind::Target &&
10433 NewMVType != MultiVersionKind::Target) ||
10434 (NewMVType == MultiVersionKind::Target &&
10435 OldMVType != MultiVersionKind::Target)) {
10436 S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed);
10437 S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
10438 NewFD->setInvalidDecl();
10439 return true;
10440 }
10441
10442 ParsedTargetAttr NewParsed;
10443 if (NewTA) {
10444 NewParsed = NewTA->parse();
10445 llvm::sort(NewParsed.Features);
10446 }
10447
10448 bool UseMemberUsingDeclRules =
10449 S.CurContext->isRecord() && !NewFD->getFriendObjectKind();
10450
10451 // Next, check ALL non-overloads to see if this is a redeclaration of a
10452 // previous member of the MultiVersion set.
10453 for (NamedDecl *ND : Previous) {
10454 FunctionDecl *CurFD = ND->getAsFunction();
10455 if (!CurFD)
10456 continue;
10457 if (S.IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
10458 continue;
10459
10460 if (NewMVType == MultiVersionKind::Target) {
10461 const auto *CurTA = CurFD->getAttr<TargetAttr>();
10462 if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
10463 NewFD->setIsMultiVersion();
10464 Redeclaration = true;
10465 OldDecl = ND;
10466 return false;
10467 }
10468
10469 ParsedTargetAttr CurParsed = CurTA->parse(std::less<std::string>());
10470 if (CurParsed == NewParsed) {
10471 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
10472 S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
10473 NewFD->setInvalidDecl();
10474 return true;
10475 }
10476 } else {
10477 const auto *CurCPUSpec = CurFD->getAttr<CPUSpecificAttr>();
10478 const auto *CurCPUDisp = CurFD->getAttr<CPUDispatchAttr>();
10479 // Handle CPUDispatch/CPUSpecific versions.
10480 // Only 1 CPUDispatch function is allowed, this will make it go through
10481 // the redeclaration errors.
10482 if (NewMVType == MultiVersionKind::CPUDispatch &&
10483 CurFD->hasAttr<CPUDispatchAttr>()) {
10484 if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() &&
10485 std::equal(
10486 CurCPUDisp->cpus_begin(), CurCPUDisp->cpus_end(),
10487 NewCPUDisp->cpus_begin(),
10488 [](const IdentifierInfo *Cur, const IdentifierInfo *New) {
10489 return Cur->getName() == New->getName();
10490 })) {
10491 NewFD->setIsMultiVersion();
10492 Redeclaration = true;
10493 OldDecl = ND;
10494 return false;
10495 }
10496
10497 // If the declarations don't match, this is an error condition.
10498 S.Diag(NewFD->getLocation(), diag::err_cpu_dispatch_mismatch);
10499 S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
10500 NewFD->setInvalidDecl();
10501 return true;
10502 }
10503 if (NewMVType == MultiVersionKind::CPUSpecific && CurCPUSpec) {
10504
10505 if (CurCPUSpec->cpus_size() == NewCPUSpec->cpus_size() &&
10506 std::equal(
10507 CurCPUSpec->cpus_begin(), CurCPUSpec->cpus_end(),
10508 NewCPUSpec->cpus_begin(),
10509 [](const IdentifierInfo *Cur, const IdentifierInfo *New) {
10510 return Cur->getName() == New->getName();
10511 })) {
10512 NewFD->setIsMultiVersion();
10513 Redeclaration = true;
10514 OldDecl = ND;
10515 return false;
10516 }
10517
10518 // Only 1 version of CPUSpecific is allowed for each CPU.
10519 for (const IdentifierInfo *CurII : CurCPUSpec->cpus()) {
10520 for (const IdentifierInfo *NewII : NewCPUSpec->cpus()) {
10521 if (CurII == NewII) {
10522 S.Diag(NewFD->getLocation(), diag::err_cpu_specific_multiple_defs)
10523 << NewII;
10524 S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
10525 NewFD->setInvalidDecl();
10526 return true;
10527 }
10528 }
10529 }
10530 }
10531 // If the two decls aren't the same MVType, there is no possible error
10532 // condition.
10533 }
10534 }
10535
10536 // Else, this is simply a non-redecl case. Checking the 'value' is only
10537 // necessary in the Target case, since The CPUSpecific/Dispatch cases are
10538 // handled in the attribute adding step.
10539 if (NewMVType == MultiVersionKind::Target &&
10540 CheckMultiVersionValue(S, NewFD)) {
10541 NewFD->setInvalidDecl();
10542 return true;
10543 }
10544
10545 if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD,
10546 !OldFD->isMultiVersion(), NewMVType)) {
10547 NewFD->setInvalidDecl();
10548 return true;
10549 }
10550
10551 // Permit forward declarations in the case where these two are compatible.
10552 if (!OldFD->isMultiVersion()) {
10553 OldFD->setIsMultiVersion();
10554 NewFD->setIsMultiVersion();
10555 Redeclaration = true;
10556 OldDecl = OldFD;
10557 return false;
10558 }
10559
10560 NewFD->setIsMultiVersion();
10561 Redeclaration = false;
10562 MergeTypeWithPrevious = false;
10563 OldDecl = nullptr;
10564 Previous.clear();
10565 return false;
10566}
10567
10568
10569/// Check the validity of a mulitversion function declaration.
10570/// Also sets the multiversion'ness' of the function itself.
10571///
10572/// This sets NewFD->isInvalidDecl() to true if there was an error.
10573///
10574/// Returns true if there was an error, false otherwise.
10576 bool &Redeclaration, NamedDecl *&OldDecl,
10577 bool &MergeTypeWithPrevious,
10579 const auto *NewTA = NewFD->getAttr<TargetAttr>();
10580 const auto *NewCPUDisp = NewFD->getAttr<CPUDispatchAttr>();
10581 const auto *NewCPUSpec = NewFD->getAttr<CPUSpecificAttr>();
10582
10583 // Mixing Multiversioning types is prohibited.
10584 if ((NewTA && NewCPUDisp) || (NewTA && NewCPUSpec) ||
10585 (NewCPUDisp && NewCPUSpec)) {
10586 S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed);
10587 NewFD->setInvalidDecl();
10588 return true;
10589 }
10590
10591 MultiVersionKind MVType = NewFD->getMultiVersionKind();
10592
10593 // Main isn't allowed to become a multiversion function, however it IS
10594 // permitted to have 'main' be marked with the 'target' optimization hint.
10595 if (NewFD->isMain()) {
10596 if ((MVType == MultiVersionKind::Target && NewTA->isDefaultVersion()) ||
10599 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_allowed_on_main);
10600 NewFD->setInvalidDecl();
10601 return true;
10602 }
10603 return false;
10604 }
10605
10606 if (!OldDecl || !OldDecl->getAsFunction() ||
10607 OldDecl->getDeclContext()->getRedeclContext() !=
10608 NewFD->getDeclContext()->getRedeclContext()) {
10609 // If there's no previous declaration, AND this isn't attempting to cause
10610 // multiversioning, this isn't an error condition.
10611 if (MVType == MultiVersionKind::None)
10612 return false;
10613 return CheckMultiVersionFirstFunction(S, NewFD, MVType, NewTA);
10614 }
10615
10616 FunctionDecl *OldFD = OldDecl->getAsFunction();
10617
10618 if (!OldFD->isMultiVersion() && MVType == MultiVersionKind::None)
10619 return false;
10620
10621 if (OldFD->isMultiVersion() && MVType == MultiVersionKind::None) {
10622 S.Diag(NewFD->getLocation(), diag::err_multiversion_required_in_redecl)
10624 NewFD->setInvalidDecl();
10625 return true;
10626 }
10627
10628 // Handle the target potentially causes multiversioning case.
10629 if (!OldFD->isMultiVersion() && MVType == MultiVersionKind::Target)
10630 return CheckTargetCausesMultiVersioning(S, OldFD, NewFD, NewTA,
10631 Redeclaration, OldDecl,
10632 MergeTypeWithPrevious, Previous);
10633
10634 // At this point, we have a multiversion function decl (in OldFD) AND an
10635 // appropriate attribute in the current function decl. Resolve that these are
10636 // still compatible with previous declarations.
10638 S, OldFD, NewFD, MVType, NewTA, NewCPUDisp, NewCPUSpec, Redeclaration,
10639 OldDecl, MergeTypeWithPrevious, Previous);
10640}
10641
10642/// Perform semantic checking of a new function declaration.
10643///
10644/// Performs semantic analysis of the new function declaration
10645/// NewFD. This routine performs all semantic checking that does not
10646/// require the actual declarator involved in the declaration, and is
10647/// used both for the declaration of functions as they are parsed
10648/// (called via ActOnDeclarator) and for the declaration of functions
10649/// that have been instantiated via C++ template instantiation (called
10650/// via InstantiateDecl).
10651///
10652/// \param IsMemberSpecialization whether this new function declaration is
10653/// a member specialization (that replaces any definition provided by the
10654/// previous declaration).
10655///
10656/// This sets NewFD->isInvalidDecl() to true if there was an error.
10657///
10658/// \returns true if the function declaration is a redeclaration.
10661 bool IsMemberSpecialization) {
10662 assert(!NewFD->getReturnType()->isVariablyModifiedType() &&
10663 "Variably modified return types are not handled here");
10664
10665 // Determine whether the type of this function should be merged with
10666 // a previous visible declaration. This never happens for functions in C++,
10667 // and always happens in C if the previous declaration was visible.
10668 bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus &&
10669 !Previous.isShadowed();
10670
10671 bool Redeclaration = false;
10672 NamedDecl *OldDecl = nullptr;
10673 bool MayNeedOverloadableChecks = false;
10674
10675 // Merge or overload the declaration with an existing declaration of
10676 // the same name, if appropriate.
10677 if (!Previous.empty()) {
10678 // Determine whether NewFD is an overload of PrevDecl or
10679 // a declaration that requires merging. If it's an overload,
10680 // there's no more work to do here; we'll just add the new
10681 // function to the scope.
10683 NamedDecl *Candidate = Previous.getRepresentativeDecl();
10684 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
10685 Redeclaration = true;
10686 OldDecl = Candidate;
10687 }
10688 } else {
10689 MayNeedOverloadableChecks = true;
10690 switch (CheckOverload(S, NewFD, Previous, OldDecl,
10691 /*NewIsUsingDecl*/ false)) {
10692 case Ovl_Match:
10693 Redeclaration = true;
10694 break;
10695
10696 case Ovl_NonFunction:
10697 Redeclaration = true;
10698 break;
10699
10700 case Ovl_Overload:
10701 Redeclaration = false;
10702 break;
10703 }
10704 }
10705 }
10706
10707 // Check for a previous extern "C" declaration with this name.
10708 if (!Redeclaration &&
10710 if (!Previous.empty()) {
10711 // This is an extern "C" declaration with the same name as a previous
10712 // declaration, and thus redeclares that entity...
10713 Redeclaration = true;
10714 OldDecl = Previous.getFoundDecl();
10715 MergeTypeWithPrevious = false;
10716
10717 // ... except in the presence of __attribute__((overloadable)).
10718 if (OldDecl->hasAttr<OverloadableAttr>() ||
10719 NewFD->hasAttr<OverloadableAttr>()) {
10720 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
10721 MayNeedOverloadableChecks = true;
10722 Redeclaration = false;
10723 OldDecl = nullptr;
10724 }
10725 }
10726 }
10727 }
10728
10729 if (CheckMultiVersionFunction(*this, NewFD, Redeclaration, OldDecl,
10730 MergeTypeWithPrevious, Previous))
10731 return Redeclaration;
10732
10733 // PPC MMA non-pointer types are not allowed as function return types.
10734 if (Context.getTargetInfo().getTriple().isPPC64() &&
10735 CheckPPCMMAType(NewFD->getReturnType(), NewFD->getLocation())) {
10736 NewFD->setInvalidDecl();
10737 }
10738
10739 // C++11 [dcl.constexpr]p8:
10740 // A constexpr specifier for a non-static member function that is not
10741 // a constructor declares that member function to be const.
10742 //
10743 // This needs to be delayed until we know whether this is an out-of-line
10744 // definition of a static member function.
10745 //
10746 // This rule is not present in C++1y, so we produce a backwards
10747 // compatibility warning whenever it happens in C++11.
10748 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
10749 if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() &&
10750 !MD->isStatic() && !isa<CXXConstructorDecl>(MD) &&
10751 !isa<CXXDestructorDecl>(MD) && !MD->getMethodQualifiers().hasConst()) {
10752 CXXMethodDecl *OldMD = nullptr;
10753 if (OldDecl)
10754 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->getAsFunction());
10755 if (!OldMD || !OldMD->isStatic()) {
10756 const FunctionProtoType *FPT =
10759 EPI.TypeQuals.addConst();
10761 FPT->getParamTypes(), EPI));
10762
10763 // Warn that we did this, if we're not performing template instantiation.
10764 // In that case, we'll have warned already when the template was defined.
10765 if (!inTemplateInstantiation()) {
10766 SourceLocation AddConstLoc;
10769 AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc());
10770
10771 Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const)
10772 << FixItHint::CreateInsertion(AddConstLoc, " const");
10773 }
10774 }
10775 }
10776
10777 if (Redeclaration) {
10778 // NewFD and OldDecl represent declarations that need to be
10779 // merged.
10780 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) {
10781 NewFD->setInvalidDecl();
10782 return Redeclaration;
10783 }
10784
10785 Previous.clear();
10786 Previous.addDecl(OldDecl);
10787
10788 if (FunctionTemplateDecl *OldTemplateDecl =
10789 dyn_cast<FunctionTemplateDecl>(OldDecl)) {
10790 auto *OldFD = OldTemplateDecl->getTemplatedDecl();
10791 FunctionTemplateDecl *NewTemplateDecl
10793 assert(NewTemplateDecl && "Template/non-template mismatch");
10794
10795 // The call to MergeFunctionDecl above may have created some state in
10796 // NewTemplateDecl that needs to be merged with OldTemplateDecl before we
10797 // can add it as a redeclaration.
10798 NewTemplateDecl->mergePrevDecl(OldTemplateDecl);
10799
10800 NewFD->setPreviousDeclaration(OldFD);
10801 if (NewFD->isCXXClassMember()) {
10802 NewFD->setAccess(OldTemplateDecl->getAccess());
10803 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
10804 }
10805
10806 // If this is an explicit specialization of a member that is a function
10807 // template, mark it as a member specialization.
10808 if (IsMemberSpecialization &&
10809 NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
10810 NewTemplateDecl->setMemberSpecialization();
10811 assert(OldTemplateDecl->isMemberSpecialization());
10812 // Explicit specializations of a member template do not inherit deleted
10813 // status from the parent member template that they are specializing.
10814 if (OldFD->isDeleted()) {
10815 // FIXME: This assert will not hold in the presence of modules.
10816 assert(OldFD->getCanonicalDecl() == OldFD);
10817 // FIXME: We need an update record for this AST mutation.
10818 OldFD->setDeletedAsWritten(false);
10819 }
10820 }
10821
10822 } else {
10823 if (shouldLinkDependentDeclWithPrevious(NewFD, OldDecl)) {
10824 auto *OldFD = cast<FunctionDecl>(OldDecl);
10825 // This needs to happen first so that 'inline' propagates.
10826 NewFD->setPreviousDeclaration(OldFD);
10827 if (NewFD->isCXXClassMember())
10828 NewFD->setAccess(OldFD->getAccess());
10829 }
10830 }
10831 } else if (!getLangOpts().CPlusPlus && MayNeedOverloadableChecks &&
10832 !NewFD->getAttr<OverloadableAttr>()) {
10833 assert((Previous.empty() ||
10834 llvm::any_of(Previous,
10835 [](const NamedDecl *ND) {
10836 return ND->hasAttr<OverloadableAttr>();
10837 })) &&
10838 "Non-redecls shouldn't happen without overloadable present");
10839
10840 auto OtherUnmarkedIter = llvm::find_if(Previous, [](const NamedDecl *ND) {
10841 const auto *FD = dyn_cast<FunctionDecl>(ND);
10842 return FD && !FD->hasAttr<OverloadableAttr>();
10843 });
10844
10845 if (OtherUnmarkedIter != Previous.end()) {
10846 Diag(NewFD->getLocation(),
10847 diag::err_attribute_overloadable_multiple_unmarked_overloads);
10848 Diag((*OtherUnmarkedIter)->getLocation(),
10849 diag::note_attribute_overloadable_prev_overload)
10850 << false;
10851
10853 }
10854 }
10855
10856 if (LangOpts.OpenMP)
10858
10859 // Semantic checking for this function declaration (in isolation).
10860
10861 if (getLangOpts().CPlusPlus) {
10862 // C++-specific checks.
10863 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
10864 CheckConstructor(Constructor);
10865 } else if (CXXDestructorDecl *Destructor =
10866 dyn_cast<CXXDestructorDecl>(NewFD)) {
10867 CXXRecordDecl *Record = Destructor->getParent();
10868 QualType ClassType = Context.getTypeDeclType(Record);
10869
10870 // FIXME: Shouldn't we be able to perform this check even when the class
10871 // type is dependent? Both gcc and edg can handle that.
10872 if (!ClassType->isDependentType()) {
10873 DeclarationName Name
10875 Context.getCanonicalType(ClassType));
10876 if (NewFD->getDeclName() != Name) {
10877 Diag(NewFD->getLocation(), diag::err_destructor_name);
10878 NewFD->setInvalidDecl();
10879 return Redeclaration;
10880 }
10881 }
10882 } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
10883 if (auto *TD = Guide->getDescribedFunctionTemplate())
10885
10886 // A deduction guide is not on the list of entities that can be
10887 // explicitly specialized.
10888 if (Guide->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
10889 Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized)
10890 << /*explicit specialization*/ 1;
10891 }
10892
10893 // Find any virtual functions that this function overrides.
10894 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
10895 if (!Method->isFunctionTemplateSpecialization() &&
10896 !Method->getDescribedFunctionTemplate() &&
10897 Method->isCanonicalDecl()) {
10898 AddOverriddenMethods(Method->getParent(), Method);
10899 }
10900 if (Method->isVirtual() && NewFD->getTrailingRequiresClause())
10901 // C++2a [class.virtual]p6
10902 // A virtual method shall not have a requires-clause.
10904 diag::err_constrained_virtual_method);
10905
10906 if (Method->isStatic())
10908 }
10909
10910 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(NewFD))
10911 ActOnConversionDeclarator(Conversion);
10912
10913 // Extra checking for C++ overloaded operators (C++ [over.oper]).
10914 if (NewFD->isOverloadedOperator() &&
10916 NewFD->setInvalidDecl();
10917 return Redeclaration;
10918 }
10919
10920 // Extra checking for C++0x literal operators (C++0x [over.literal]).
10921 if (NewFD->getLiteralIdentifier() &&
10923 NewFD->setInvalidDecl();
10924 return Redeclaration;
10925 }
10926
10927 // In C++, check default arguments now that we have merged decls. Unless
10928 // the lexical context is the class, because in this case this is done
10929 // during delayed parsing anyway.
10930 if (!CurContext->isRecord())
10932
10933 // If this function declares a builtin function, check the type of this
10934 // declaration against the expected type for the builtin.
10935 if (unsigned BuiltinID = NewFD->getBuiltinID()) {
10937 LookupNecessaryTypesForBuiltin(S, BuiltinID);
10938 QualType T = Context.GetBuiltinType(BuiltinID, Error);
10939 // If the type of the builtin differs only in its exception
10940 // specification, that's OK.
10941 // FIXME: If the types do differ in this way, it would be better to
10942 // retain the 'noexcept' form of the type.
10943 if (!T.isNull() &&
10945 NewFD->getType()))
10946 // The type of this function differs from the type of the builtin,
10947 // so forget about the builtin entirely.
10949 }
10950
10951 // If this function is declared as being extern "C", then check to see if
10952 // the function returns a UDT (class, struct, or union type) that is not C
10953 // compatible, and if it does, warn the user.
10954 // But, issue any diagnostic on the first declaration only.
10955 if (Previous.empty() && NewFD->isExternC()) {
10956 QualType R = NewFD->getReturnType();
10957 if (R->isIncompleteType() && !R->isVoidType())
10958 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
10959 << NewFD << R;
10960 else if (!R.isPODType(Context) && !R->isVoidType() &&
10962 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
10963 }
10964
10965 // C++1z [dcl.fct]p6:
10966 // [...] whether the function has a non-throwing exception-specification
10967 // [is] part of the function type
10968 //
10969 // This results in an ABI break between C++14 and C++17 for functions whose
10970 // declared type includes an exception-specification in a parameter or
10971 // return type. (Exception specifications on the function itself are OK in
10972 // most cases, and exception specifications are not permitted in most other
10973 // contexts where they could make it into a mangling.)
10974 if (!getLangOpts().CPlusPlus17 && !NewFD->getPrimaryTemplate()) {
10975 auto HasNoexcept = [&](QualType T) -> bool {
10976 // Strip off declarator chunks that could be between us and a function
10977 // type. We don't need to look far, exception specifications are very
10978 // restricted prior to C++17.
10979 if (auto *RT = T->getAs<ReferenceType>())
10980 T = RT->getPointeeType();
10981 else if (T->isAnyPointerType())
10982 T = T->getPointeeType();
10983 else if (auto *MPT = T->getAs<MemberPointerType>())
10984 T = MPT->getPointeeType();
10985 if (auto *FPT = T->getAs<FunctionProtoType>())
10986 if (FPT->isNothrow())
10987 return true;
10988 return false;
10989 };
10990
10991 auto *FPT = NewFD->getType()->castAs<FunctionProtoType>();
10992 bool AnyNoexcept = HasNoexcept(FPT->getReturnType());
10993 for (QualType T : FPT->param_types())
10994 AnyNoexcept |= HasNoexcept(T);
10995 if (AnyNoexcept)
10996 Diag(NewFD->getLocation(),
10997 diag::warn_cxx17_compat_exception_spec_in_signature)
10998 << NewFD;
10999 }
11000
11001 if (!Redeclaration && LangOpts.CUDA)
11003 }
11004 return Redeclaration;
11005}
11006
11008 // C++11 [basic.start.main]p3:
11009 // A program that [...] declares main to be inline, static or
11010 // constexpr is ill-formed.
11011 // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall
11012 // appear in a declaration of main.
11013 // static main is not an error under C99, but we should warn about it.
11014 // We accept _Noreturn main as an extension.
11015 if (FD->getStorageClass() == SC_Static)
11017 ? diag::err_static_main : diag::warn_static_main)
11019 if (FD->isInlineSpecified())
11020 Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
11022 if (DS.isNoreturnSpecified()) {
11023 SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
11024 SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
11025 Diag(NoreturnLoc, diag::ext_noreturn_main);
11026 Diag(NoreturnLoc, diag::note_main_remove_noreturn)
11027 << FixItHint::CreateRemoval(NoreturnRange);
11028 }
11029 if (FD->isConstexpr()) {
11030 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
11031 << FD->isConsteval()
11034 }
11035
11036 if (getLangOpts().OpenCL) {
11037 Diag(FD->getLocation(), diag::err_opencl_no_main)
11038 << FD->hasAttr<OpenCLKernelAttr>();
11039 FD->setInvalidDecl();
11040 return;
11041 }
11042
11043 QualType T = FD->getType();
11044 assert(T->isFunctionType() && "function decl is not of function type");
11045 const FunctionType* FT = T->castAs<FunctionType>();
11046
11047 // Set default calling convention for main()
11048 if (FT->getCallConv() != CC_C) {
11050 FD->setType(QualType(FT, 0));
11051 T = Context.getCanonicalType(FD->getType());
11052 }
11053
11055 // In C with GNU extensions we allow main() to have non-integer return
11056 // type, but we should warn about the extension, and we disable the
11057 // implicit-return-zero rule.
11058
11059 // GCC in C mode accepts qualified 'int'.
11061 FD->setHasImplicitReturnZero(true);
11062 else {
11063 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
11064 SourceRange RTRange = FD->getReturnTypeSourceRange();
11065 if (RTRange.isValid())
11066 Diag(RTRange.getBegin(), diag::note_main_change_return_type)
11067 << FixItHint::CreateReplacement(RTRange, "int");
11068 }
11069 } else {
11070 // In C and C++, main magically returns 0 if you fall off the end;
11071 // set the flag which tells us that.
11072 // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3.
11073
11074 // All the standards say that main() should return 'int'.
11076 FD->setHasImplicitReturnZero(true);
11077 else {
11078 // Otherwise, this is just a flat-out error.
11079 SourceRange RTRange = FD->getReturnTypeSourceRange();
11080 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
11081 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int")
11082 : FixItHint());
11083 FD->setInvalidDecl(true);
11084 }
11085 }
11086
11087 // Treat protoless main() as nullary.
11088 if (isa<FunctionNoProtoType>(FT)) return;
11089
11091 unsigned nparams = FTP->getNumParams();
11092 assert(FD->getNumParams() == nparams);
11093
11094 bool HasExtraParameters = (nparams > 3);
11095
11096 if (FTP->isVariadic()) {
11097 Diag(FD->getLocation(), diag::ext_variadic_main);
11098 // FIXME: if we had information about the location of the ellipsis, we
11099 // could add a FixIt hint to remove it as a parameter.
11100 }
11101
11102 // Darwin passes an undocumented fourth argument of type char**. If
11103 // other platforms start sprouting these, the logic below will start
11104 // getting shifty.
11105 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
11106 HasExtraParameters = false;
11107
11108 if (HasExtraParameters) {
11109 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
11110 FD->setInvalidDecl(true);
11111 nparams = 3;
11112 }
11113
11114 // FIXME: a lot of the following diagnostics would be improved
11115 // if we had some location information about types.
11116
11117 QualType CharPP =
11119 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
11120
11121 for (unsigned i = 0; i < nparams; ++i) {
11122 QualType AT = FTP->getParamType(i);
11123
11124 bool mismatch = true;
11125
11127 mismatch = false;
11128 else if (Expected[i] == CharPP) {
11129 // As an extension, the following forms are okay:
11130 // char const **
11131 // char const * const *
11132 // char * const *
11133
11135 const PointerType* PT;
11136 if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
11137 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
11139 Context.CharTy)) {
11140 qs.removeConst();
11141 mismatch = !qs.empty();
11142 }
11143 }
11144
11145 if (mismatch) {
11146 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
11147 // TODO: suggest replacing given type with expected type
11148 FD->setInvalidDecl(true);
11149 }
11150 }
11151
11152 if (nparams == 1 && !FD->isInvalidDecl()) {
11153 Diag(FD->getLocation(), diag::warn_main_one_arg);
11154 }
11155
11156 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
11157 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
11158 FD->setInvalidDecl();
11159 }
11160}
11161
11163 QualType T = FD->getType();
11164 assert(T->isFunctionType() && "function decl is not of function type");
11165 const FunctionType *FT = T->castAs<FunctionType>();
11166
11167 // Set an implicit return of 'zero' if the function can return some integral,
11168 // enumeration, pointer or nullptr type.
11172 // DllMain is exempt because a return value of zero means it failed.
11173 if (FD->getName() != "DllMain")
11174 FD->setHasImplicitReturnZero(true);
11175
11176 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
11177 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
11178 FD->setInvalidDecl();
11179 }
11180}
11181
11183 // FIXME: Need strict checking. In C89, we need to check for
11184 // any assignment, increment, decrement, function-calls, or
11185 // commas outside of a sizeof. In C99, it's the same list,
11186 // except that the aforementioned are allowed in unevaluated
11187 // expressions. Everything else falls under the
11188 // "may accept other forms of constant expressions" exception.
11189 //
11190 // Regular C++ code will not end up here (exceptions: language extensions,
11191 // OpenCL C++ etc), so the constant expression rules there don't matter.
11192 if (Init->isValueDependent()) {
11193 assert(Init->containsErrors() &&
11194 "Dependent code should only occur in error-recovery path.");
11195 return true;
11196 }
11197 const Expr *Culprit;
11198 if (Init->isConstantInitializer(Context, false, &Culprit))
11199 return false;
11200 Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant)
11201 << Culprit->getSourceRange();
11202 return true;
11203}
11204
11205namespace {
11206 // Visits an initialization expression to see if OrigDecl is evaluated in
11207 // its own initialization and throws a warning if it does.
11208 class SelfReferenceChecker
11209 : public EvaluatedExprVisitor<SelfReferenceChecker> {
11210 Sema &S;
11211 Decl *OrigDecl;
11212 bool isRecordType;
11213 bool isPODType;
11214 bool isReferenceType;
11215
11216 bool isInitList;
11217 llvm::SmallVector<unsigned, 4> InitFieldIndex;
11218
11219 public:
11221
11222 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
11223 S(S), OrigDecl(OrigDecl) {
11224 isPODType = false;
11225 isRecordType = false;
11226 isReferenceType = false;
11227 isInitList = false;
11228 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
11229 isPODType = VD->getType().isPODType(S.Context);
11230 isRecordType = VD->getType()->isRecordType();
11231 isReferenceType = VD->getType()->isReferenceType();
11232 }
11233 }
11234
11235 // For most expressions, just call the visitor. For initializer lists,
11236 // track the index of the field being initialized since fields are
11237 // initialized in order allowing use of previously initialized fields.
11238 void CheckExpr(Expr *E) {
11239 InitListExpr *InitList = dyn_cast<InitListExpr>(E);
11240 if (!InitList) {
11241 Visit(E);
11242 return;
11243 }
11244
11245 // Track and increment the index here.
11246 isInitList = true;
11247 InitFieldIndex.push_back(0);
11248 for (auto Child : InitList->children()) {
11249 CheckExpr(cast<Expr>(Child));
11250 ++InitFieldIndex.back();
11251 }
11252 InitFieldIndex.pop_back();
11253 }
11254
11255 // Returns true if MemberExpr is checked and no further checking is needed.
11256 // Returns false if additional checking is required.
11257 bool CheckInitListMemberExpr(MemberExpr *E, bool CheckReference) {
11259 Expr *Base = E;
11260 bool ReferenceField = false;
11261
11262 // Get the field members used.
11263 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
11264 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
11265 if (!FD)
11266 return false;
11267 Fields.push_back(FD);
11268 if (FD->getType()->isReferenceType())
11269 ReferenceField = true;
11270 Base = ME->getBase()->IgnoreParenImpCasts();
11271 }
11272
11273 // Keep checking only if the base Decl is the same.
11274 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base);
11275 if (!DRE || DRE->getDecl() != OrigDecl)
11276 return false;
11277
11278 // A reference field can be bound to an unininitialized field.
11279 if (CheckReference && !ReferenceField)
11280 return true;
11281
11282 // Convert FieldDecls to their index number.
11283 llvm::SmallVector<unsigned, 4> UsedFieldIndex;
11284 for (const FieldDecl *I : llvm::reverse(Fields))
11285 UsedFieldIndex.push_back(I->getFieldIndex());
11286
11287 // See if a warning is needed by checking the first difference in index
11288 // numbers. If field being used has index less than the field being
11289 // initialized, then the use is safe.
11290 for (auto UsedIter = UsedFieldIndex.begin(),
11291 UsedEnd = UsedFieldIndex.end(),
11292 OrigIter = InitFieldIndex.begin(),
11293 OrigEnd = InitFieldIndex.end();
11294 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
11295 if (*UsedIter < *OrigIter)
11296 return true;
11297 if (*UsedIter > *OrigIter)
11298 break;
11299 }
11300
11301 // TODO: Add a different warning which will print the field names.
11302 HandleDeclRefExpr(DRE);
11303 return true;
11304 }
11305
11306 // For most expressions, the cast is directly above the DeclRefExpr.
11307 // For conditional operators, the cast can be outside the conditional
11308 // operator if both expressions are DeclRefExpr's.
11309 void HandleValue(Expr *E) {
11310 E = E->IgnoreParens();
11311 if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
11312 HandleDeclRefExpr(DRE);
11313 return;
11314 }
11315
11316 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
11317 Visit(CO->getCond());
11318 HandleValue(CO->getTrueExpr());
11319 HandleValue(CO->getFalseExpr());
11320 return;
11321 }
11322
11323 if (BinaryConditionalOperator *BCO =
11324 dyn_cast<BinaryConditionalOperator>(E)) {
11325 Visit(BCO->getCond());
11326 HandleValue(BCO->getFalseExpr());
11327 return;
11328 }
11329
11330 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
11331 HandleValue(OVE->getSourceExpr());
11332 return;
11333 }
11334
11335 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
11336 if (BO->getOpcode() == BO_Comma) {
11337 Visit(BO->getLHS());
11338 HandleValue(BO->getRHS());
11339 return;
11340 }
11341 }
11342
11343 if (isa<MemberExpr>(E)) {
11344 if (isInitList) {
11345 if (CheckInitListMemberExpr(cast<MemberExpr>(E),
11346 false /*CheckReference*/))
11347 return;
11348 }
11349
11351 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
11352 // Check for static member variables and don't warn on them.
11353 if (!isa<FieldDecl>(ME->getMemberDecl()))
11354 return;
11355 Base = ME->getBase()->IgnoreParenImpCasts();
11356 }
11357 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base))
11358 HandleDeclRefExpr(DRE);
11359 return;
11360 }
11361
11362 Visit(E);
11363 }
11364
11365 // Reference types not handled in HandleValue are handled here since all
11366 // uses of references are bad, not just r-value uses.
11367 void VisitDeclRefExpr(DeclRefExpr *E) {
11368 if (isReferenceType)
11369 HandleDeclRefExpr(E);
11370 }
11371
11372 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
11373 if (E->getCastKind() == CK_LValueToRValue) {
11374 HandleValue(E->getSubExpr());
11375 return;
11376 }
11377
11378 Inherited::VisitImplicitCastExpr(E);
11379 }
11380
11381 void VisitMemberExpr(MemberExpr *E) {
11382 if (isInitList) {
11383 if (CheckInitListMemberExpr(E, true /*CheckReference*/))
11384 return;
11385 }
11386
11387 // Don't warn on arrays since they can be treated as pointers.
11388 if (E->getType()->canDecayToPointerType()) return;
11389
11390 // Warn when a non-static method call is followed by non-static member
11391 // field accesses, which is followed by a DeclRefExpr.
11392 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl());
11393 bool Warn = (MD && !MD->isStatic());
11395 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
11396 if (!isa<FieldDecl>(ME->getMemberDecl()))
11397 Warn = false;
11398 Base = ME->getBase()->IgnoreParenImpCasts();
11399 }
11400
11401 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
11402 if (Warn)
11403 HandleDeclRefExpr(DRE);
11404 return;
11405 }
11406
11407 // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr.
11408 // Visit that expression.
11409 Visit(Base);
11410 }
11411
11412 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
11413 Expr *Callee = E->getCallee();
11414
11415 if (isa<UnresolvedLookupExpr>(Callee))
11416 return Inherited::VisitCXXOperatorCallExpr(E);
11417
11418 Visit(Callee);
11419 for (auto Arg: E->arguments())
11420 HandleValue(Arg->IgnoreParenImpCasts());
11421 }
11422
11423 void VisitUnaryOperator(UnaryOperator *E) {
11424 // For POD record types, addresses of its own members are well-defined.
11425 if (E->getOpcode() == UO_AddrOf && isRecordType &&
11426 isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) {
11427 if (!isPODType)
11428 HandleValue(E->getSubExpr());
11429 return;
11430 }
11431
11432 if (E->isIncrementDecrementOp()) {
11433 HandleValue(E->getSubExpr());
11434 return;
11435 }
11436
11437 Inherited::VisitUnaryOperator(E);
11438 }
11439
11440 void VisitObjCMessageExpr(ObjCMessageExpr *E) {}
11441
11442 void VisitCXXConstructExpr(CXXConstructExpr *E) {
11443 if (E->getConstructor()->isCopyConstructor()) {
11444 Expr *ArgExpr = E->getArg(0);
11445 if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
11446 if (ILE->getNumInits() == 1)
11447 ArgExpr = ILE->getInit(0);
11448 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
11449 if (ICE->getCastKind() == CK_NoOp)
11450 ArgExpr = ICE->getSubExpr();
11451 HandleValue(ArgExpr);
11452 return;
11453 }
11454 Inherited::VisitCXXConstructExpr(E);
11455 }
11456
11457 void VisitCallExpr(CallExpr *E) {
11458 // Treat std::move as a use.
11459 if (E->isCallToStdMove()) {
11460 HandleValue(E->getArg(0));
11461 return;
11462 }
11463
11464 Inherited::VisitCallExpr(E);
11465 }
11466
11467 void VisitBinaryOperator(BinaryOperator *E) {
11468 if (E->isCompoundAssignmentOp()) {
11469 HandleValue(E->getLHS());
11470 Visit(E->getRHS());
11471 return;
11472 }
11473
11474 Inherited::VisitBinaryOperator(E);
11475 }
11476
11477 // A custom visitor for BinaryConditionalOperator is needed because the
11478 // regular visitor would check the condition and true expression separately
11479 // but both point to the same place giving duplicate diagnostics.
11480 void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
11481 Visit(E->getCond());
11482 Visit(E->getFalseExpr());
11483 }
11484
11485 void HandleDeclRefExpr(DeclRefExpr *DRE) {
11486 Decl* ReferenceDecl = DRE->getDecl();
11487 if (OrigDecl != ReferenceDecl) return;
11488 unsigned diag;
11489 if (isReferenceType) {
11490 diag = diag::warn_uninit_self_reference_in_reference_init;
11491 } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
11492 diag = diag::warn_static_self_reference_in_init;
11493 } else if (isa<TranslationUnitDecl>(OrigDecl->getDeclContext()) ||
11494 isa<NamespaceDecl>(OrigDecl->getDeclContext()) ||
11495 DRE->getDecl()->getType()->isRecordType()) {
11496 diag = diag::warn_uninit_self_reference_in_init;
11497 } else {
11498 // Local variables will be handled by the CFG analysis.
11499 return;
11500 }
11501
11502 S.DiagRuntimeBehavior(DRE->getBeginLoc(), DRE,
11503 S.PDiag(diag)
11504 << DRE->getDecl() << OrigDecl->getLocation()
11505 << DRE->getSourceRange());
11506 }
11507 };
11508
11509 /// CheckSelfReference - Warns if OrigDecl is used in expression E.
11510 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
11511 bool DirectInit) {
11512 // Parameters arguments are occassionially constructed with itself,
11513 // for instance, in recursive functions. Skip them.
11514 if (isa<ParmVarDecl>(OrigDecl))
11515 return;
11516
11517 E = E->IgnoreParens();
11518
11519 // Skip checking T a = a where T is not a record or reference type.
11520 // Doing so is a way to silence uninitialized warnings.
11521 if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType())
11522 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
11523 if (ICE->getCastKind() == CK_LValueToRValue)
11524 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
11525 if (DRE->getDecl() == OrigDecl)
11526 return;
11527
11528 SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
11529 }
11530} // end anonymous namespace
11531
11532namespace {
11533 // Simple wrapper to add the name of a variable or (if no variable is
11534 // available) a DeclarationName into a diagnostic.
11535 struct VarDeclOrName {
11536 VarDecl *VDecl;
11537 DeclarationName Name;
11538
11539 friend const Sema::SemaDiagnosticBuilder &
11540 operator<<(const Sema::SemaDiagnosticBuilder &Diag, VarDeclOrName VN) {
11541 return VN.VDecl ? Diag << VN.VDecl : Diag << VN.Name;
11542 }
11543 };
11544} // end anonymous namespace
11545
11548 TypeSourceInfo *TSI,
11549 SourceRange Range, bool DirectInit,
11550 Expr *Init) {
11551 bool IsInitCapture = !VDecl;
11552 assert((!VDecl || !VDecl->isInitCapture()) &&
11553 "init captures are expected to be deduced prior to initialization");
11554
11555 VarDeclOrName VN{VDecl, Name};
11556
11558 assert(Deduced && "deduceVarTypeFromInitializer for non-deduced type");
11559
11560 // C++11 [dcl.spec.auto]p3
11561 if (!Init) {
11562 assert(VDecl && "no init for init capture deduction?");
11563
11564 // Except for class argument deduction, and then for an initializing
11565 // declaration only, i.e. no static at class scope or extern.
11566 if (!isa<DeducedTemplateSpecializationType>(Deduced) ||
11567 VDecl->hasExternalStorage() ||
11568 VDecl->isStaticDataMember()) {
11569 Diag(VDecl->getLocation(), diag::err_auto_var_requires_init)
11570 << VDecl->getDeclName() << Type;
11571 return QualType();
11572 }
11573 }
11574
11575 ArrayRef<Expr*> DeduceInits;
11576 if (Init)
11577 DeduceInits = Init;
11578
11579 if (DirectInit) {
11580 if (auto *PL = dyn_cast_or_null<ParenListExpr>(Init))
11581 DeduceInits = PL->exprs();
11582 }
11583
11584 if (isa<DeducedTemplateSpecializationType>(Deduced)) {
11585 assert(VDecl && "non-auto type for init capture deduction?");
11588 VDecl->getLocation(), DirectInit, Init);
11589 // FIXME: Initialization should not be taking a mutable list of inits.
11590 SmallVector<Expr*, 8> InitsCopy(DeduceInits.begin(), DeduceInits.end());
11591 return DeduceTemplateSpecializationFromInitializer(TSI, Entity, Kind,
11592 InitsCopy);
11593 }
11594
11595 if (DirectInit) {
11596 if (auto *IL = dyn_cast<InitListExpr>(Init))
11597 DeduceInits = IL->inits();
11598 }
11599
11600 // Deduction only works if we have exactly one source expression.
11601 if (DeduceInits.empty()) {
11602 // It isn't possible to write this directly, but it is possible to
11603 // end up in this situation with "auto x(some_pack...);"
11604 Diag(Init->getBeginLoc(), IsInitCapture
11605 ? diag::err_init_capture_no_expression
11606 : diag::err_auto_var_init_no_expression)
11607 << VN << Type << Range;
11608 return QualType();
11609 }
11610
11611 if (DeduceInits.size() > 1) {
11612 Diag(DeduceInits[1]->getBeginLoc(),
11613 IsInitCapture ? diag::err_init_capture_multiple_expressions
11614 : diag::err_auto_var_init_multiple_expressions)
11615 << VN << Type << Range;
11616 return QualType();
11617 }
11618
11619 Expr *DeduceInit = DeduceInits[0];
11620 if (DirectInit && isa<InitListExpr>(DeduceInit)) {
11621 Diag(Init->getBeginLoc(), IsInitCapture
11622 ? diag::err_init_capture_paren_braces
11623 : diag::err_auto_var_init_paren_braces)
11624 << isa<InitListExpr>(Init) << VN << Type << Range;
11625 return QualType();
11626 }
11627
11628 // Expressions default to 'id' when we're in a debugger.
11629 bool DefaultedAnyToId = false;
11630 if (getLangOpts().DebuggerCastResultToId &&
11631 Init->getType() == Context.UnknownAnyTy && !IsInitCapture) {
11633 if (Result.isInvalid()) {
11634 return QualType();
11635 }
11636 Init = Result.get();
11637 DefaultedAnyToId = true;
11638 }
11639
11640 // C++ [dcl.decomp]p1:
11641 // If the assignment-expression [...] has array type A and no ref-qualifier
11642 // is present, e has type cv A
11643 if (VDecl && isa<DecompositionDecl>(VDecl) &&
11645 DeduceInit->getType()->isConstantArrayType())
11646 return Context.getQualifiedType(DeduceInit->getType(),
11647 Type.getQualifiers());
11648
11650 if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) {
11651 if (!IsInitCapture)
11652 DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
11653 else if (isa<InitListExpr>(Init))
11654 Diag(Range.getBegin(),
11655 diag::err_init_capture_deduction_failure_from_init_list)
11656 << VN
11657 << (DeduceInit->getType().isNull() ? TSI->getType()
11658 : DeduceInit->getType())
11659 << DeduceInit->getSourceRange();
11660 else
11661 Diag(Range.getBegin(), diag::err_init_capture_deduction_failure)
11662 << VN << TSI->getType()
11663 << (DeduceInit->getType().isNull() ? TSI->getType()
11664 : DeduceInit->getType())
11665 << DeduceInit->getSourceRange();
11666 }
11667
11668 // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
11669 // 'id' instead of a specific object type prevents most of our usual
11670 // checks.
11671 // We only want to warn outside of template instantiations, though:
11672 // inside a template, the 'id' could have come from a parameter.
11673 if (!inTemplateInstantiation() && !DefaultedAnyToId && !IsInitCapture &&
11674 !DeducedType.isNull() && DeducedType->isObjCIdType()) {
11675 SourceLocation Loc = TSI->getTypeLoc().getBeginLoc();
11676 Diag(Loc, diag::warn_auto_var_is_id) << VN << Range;
11677 }
11678
11679 return DeducedType;
11680}
11681
11683 Expr *Init) {
11684 assert(!Init || !Init->containsErrors());
11686 VDecl, VDecl->getDeclName(), VDecl->getType(), VDecl->getTypeSourceInfo(),
11687 VDecl->getSourceRange(), DirectInit, Init);
11688 if (DeducedType.isNull()) {
11689 VDecl->setInvalidDecl();
11690 return true;
11691 }
11692
11693 VDecl->setType(DeducedType);
11694 assert(VDecl->isLinkageValid());
11695
11696 // In ARC, infer lifetime.
11697 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
11698 VDecl->setInvalidDecl();
11699
11700 if (getLangOpts().OpenCL)
11702
11703 // If this is a redeclaration, check that the type we just deduced matches
11704 // the previously declared type.
11705 if (VarDecl *Old = VDecl->getPreviousDecl()) {
11706 // We never need to merge the type, because we cannot form an incomplete
11707 // array of auto, nor deduce such a type.
11708 MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/ false);
11709 }
11710
11711 // Check the deduced type is valid for a variable declaration.
11713 return VDecl->isInvalidDecl();
11714}
11715
11717 SourceLocation Loc) {
11718 if (auto *EWC = dyn_cast<ExprWithCleanups>(Init))
11719 Init = EWC->getSubExpr();
11720
11721 if (auto *CE = dyn_cast<ConstantExpr>(Init))
11722 Init = CE->getSubExpr();
11723
11724 QualType InitType = Init->getType();
11727 "shouldn't be called if type doesn't have a non-trivial C struct");
11728 if (auto *ILE = dyn_cast<InitListExpr>(Init)) {
11729 for (auto I : ILE->inits()) {
11730 if (!I->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion() &&
11731 !I->getType().hasNonTrivialToPrimitiveCopyCUnion())
11732 continue;
11733 SourceLocation SL = I->getExprLoc();
11734 checkNonTrivialCUnionInInitializer(I, SL.isValid() ? SL : Loc);
11735 }
11736 return;
11737 }
11738
11739 if (isa<ImplicitValueInitExpr>(Init)) {
11742 NTCUK_Init);
11743 } else {
11744 // Assume all other explicit initializers involving copying some existing
11745 // object.
11746 // TODO: ignore any explicit initializers where we can guarantee
11747 // copy-elision.
11750 }
11751}
11752
11753namespace {
11754
11755bool shouldIgnoreForRecordTriviality(const FieldDecl *FD) {
11756 // Ignore unavailable fields. A field can be marked as unavailable explicitly
11757 // in the source code or implicitly by the compiler if it is in a union
11758 // defined in a system header and has non-trivial ObjC ownership
11759 // qualifications. We don't want those fields to participate in determining
11760 // whether the containing union is non-trivial.
11761 return FD->hasAttr<UnavailableAttr>();
11762}
11763
11764struct DiagNonTrivalCUnionDefaultInitializeVisitor
11765 : DefaultInitializedTypeVisitor<DiagNonTrivalCUnionDefaultInitializeVisitor,
11766 void> {
11767 using Super =
11768 DefaultInitializedTypeVisitor<DiagNonTrivalCUnionDefaultInitializeVisitor,
11769 void>;
11770
11771 DiagNonTrivalCUnionDefaultInitializeVisitor(
11772 QualType OrigTy, SourceLocation OrigLoc,
11773 Sema::NonTrivialCUnionContext UseContext, Sema &S)
11774 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
11775
11776 void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType QT,
11777 const FieldDecl *FD, bool InNonTrivialUnion) {
11778 if (const auto *AT = S.Context.getAsArrayType(QT))
11779 return this->asDerived().visit(S.Context.getBaseElementType(AT), FD,
11780 InNonTrivialUnion);
11781 return Super::visitWithKind(PDIK, QT, FD, InNonTrivialUnion);
11782 }
11783
11784 void visitARCStrong(QualType QT, const FieldDecl *FD,
11785 bool InNonTrivialUnion) {
11786 if (InNonTrivialUnion)
11787 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
11788 << 1 << 0 << QT << FD->getName();
11789 }
11790
11791 void visitARCWeak(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
11792 if (InNonTrivialUnion)
11793 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
11794 << 1 << 0 << QT << FD->getName();
11795 }
11796
11797 void visitStruct(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
11798 const RecordDecl *RD = QT->castAs<RecordType>()->getDecl();
11799 if (RD->isUnion()) {
11800 if (OrigLoc.isValid()) {
11801 bool IsUnion = false;
11802 if (auto *OrigRD = OrigTy->getAsRecordDecl())
11803 IsUnion = OrigRD->isUnion();
11804 S.Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
11805 << 0 << OrigTy << IsUnion << UseContext;
11806 // Reset OrigLoc so that this diagnostic is emitted only once.
11807 OrigLoc = SourceLocation();
11808 }
11809 InNonTrivialUnion = true;
11810 }
11811
11812 if (InNonTrivialUnion)
11813 S.Diag(RD->getLocation(), diag::note_non_trivial_c_union)
11814 << 0 << 0 << QT.getUnqualifiedType() << "";
11815
11816 for (const FieldDecl *FD : RD->fields())
11817 if (!shouldIgnoreForRecordTriviality(FD))
11818 asDerived().visit(FD->getType(), FD, InNonTrivialUnion);
11819 }
11820
11821 void visitTrivial(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {}
11822
11823 // The non-trivial C union type or the struct/union type that contains a
11824 // non-trivial C union.
11825 QualType OrigTy;
11826 SourceLocation OrigLoc;
11828 Sema &S;
11829};
11830
11831struct DiagNonTrivalCUnionDestructedTypeVisitor
11832 : DestructedTypeVisitor<DiagNonTrivalCUnionDestructedTypeVisitor, void> {
11833 using Super =
11835
11836 DiagNonTrivalCUnionDestructedTypeVisitor(
11837 QualType OrigTy, SourceLocation OrigLoc,
11838 Sema::NonTrivialCUnionContext UseContext, Sema &S)
11839 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
11840
11841 void visitWithKind(QualType::DestructionKind DK, QualType QT,
11842 const FieldDecl *FD, bool InNonTrivialUnion) {
11843 if (const auto *AT = S.Context.getAsArrayType(QT))
11844 return this->asDerived().visit(S.Context.getBaseElementType(AT), FD,
11845 InNonTrivialUnion);
11846 return Super::visitWithKind(DK, QT, FD, InNonTrivialUnion);
11847 }
11848
11849 void visitARCStrong(QualType QT, const FieldDecl *FD,
11850 bool InNonTrivialUnion) {
11851 if (InNonTrivialUnion)
11852 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
11853 << 1 << 1 << QT << FD->getName();
11854 }
11855
11856 void visitARCWeak(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
11857 if (InNonTrivialUnion)
11858 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
11859 << 1 << 1 << QT << FD->getName();
11860 }
11861
11862 void visitStruct(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
11863 const RecordDecl *RD = QT->castAs<RecordType>()->getDecl();
11864 if (RD->isUnion()) {
11865 if (OrigLoc.isValid()) {
11866 bool IsUnion = false;
11867 if (auto *OrigRD = OrigTy->getAsRecordDecl())
11868 IsUnion = OrigRD->isUnion();
11869 S.Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
11870 << 1 << OrigTy << IsUnion << UseContext;
11871 // Reset OrigLoc so that this diagnostic is emitted only once.
11872 OrigLoc = SourceLocation();
11873 }
11874 InNonTrivialUnion = true;
11875 }
11876
11877 if (InNonTrivialUnion)
11878 S.Diag(RD->getLocation(), diag::note_non_trivial_c_union)
11879 << 0 << 1 << QT.getUnqualifiedType() << "";
11880
11881 for (const FieldDecl *FD : RD->fields())
11882 if (!shouldIgnoreForRecordTriviality(FD))
11883 asDerived().visit(FD->getType(), FD, InNonTrivialUnion);
11884 }
11885
11886 void visitTrivial(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {}
11887 void visitCXXDestructor(QualType QT, const FieldDecl *FD,
11888 bool InNonTrivialUnion) {}
11889
11890 // The non-trivial C union type or the struct/union type that contains a
11891 // non-trivial C union.
11892 QualType OrigTy;
11893 SourceLocation OrigLoc;
11895 Sema &S;
11896};
11897
11898struct DiagNonTrivalCUnionCopyVisitor
11899 : CopiedTypeVisitor<DiagNonTrivalCUnionCopyVisitor, false, void> {
11901
11902 DiagNonTrivalCUnionCopyVisitor(QualType OrigTy, SourceLocation OrigLoc,
11904 Sema &S)
11905 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
11906
11907 void visitWithKind(QualType::PrimitiveCopyKind PCK, QualType QT,
11908 const FieldDecl *FD, bool InNonTrivialUnion) {
11909 if (const auto *AT = S.Context.getAsArrayType(QT))
11910 return this->asDerived().visit(S.Context.getBaseElementType(AT), FD,
11911 InNonTrivialUnion);
11912 return Super::visitWithKind(PCK, QT, FD, InNonTrivialUnion);
11913 }
11914
11915 void visitARCStrong(QualType QT, const FieldDecl *FD,
11916 bool InNonTrivialUnion) {
11917 if (InNonTrivialUnion)
11918 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
11919 << 1 << 2 << QT << FD->getName();
11920 }
11921
11922 void visitARCWeak(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
11923 if (InNonTrivialUnion)
11924 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
11925 << 1 << 2 << QT << FD->getName();
11926 }
11927
11928 void visitStruct(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
11929 const RecordDecl *RD = QT->castAs<RecordType>()->getDecl();
11930 if (RD->isUnion()) {
11931 if (OrigLoc.isValid()) {
11932 bool IsUnion = false;
11933 if (auto *OrigRD = OrigTy->getAsRecordDecl())
11934 IsUnion = OrigRD->isUnion();
11935 S.Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
11936 << 2 << OrigTy << IsUnion << UseContext;
11937 // Reset OrigLoc so that this diagnostic is emitted only once.
11938 OrigLoc = SourceLocation();
11939 }
11940 InNonTrivialUnion = true;
11941 }
11942
11943 if (InNonTrivialUnion)
11944 S.Diag(RD->getLocation(), diag::note_non_trivial_c_union)
11945 << 0 << 2 << QT.getUnqualifiedType() << "";
11946
11947 for (const FieldDecl *FD : RD->fields())
11948 if (!shouldIgnoreForRecordTriviality(FD))
11949 asDerived().visit(FD->getType(), FD, InNonTrivialUnion);
11950 }
11951
11952 void preVisit(QualType::PrimitiveCopyKind PCK, QualType QT,
11953 const FieldDecl *FD, bool InNonTrivialUnion) {}
11954 void visitTrivial(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {}
11955 void visitVolatileTrivial(QualType QT, const FieldDecl *FD,
11956 bool InNonTrivialUnion) {}
11957
11958 // The non-trivial C union type or the struct/union type that contains a
11959 // non-trivial C union.
11960 QualType OrigTy;
11961 SourceLocation OrigLoc;
11963 Sema &S;
11964};
11965
11966} // namespace
11967
11969 NonTrivialCUnionContext UseContext,
11970 unsigned NonTrivialKind) {
11974 "shouldn't be called if type doesn't have a non-trivial C union");
11975
11976 if ((NonTrivialKind & NTCUK_Init) &&
11978 DiagNonTrivalCUnionDefaultInitializeVisitor(QT, Loc, UseContext, *this)
11979 .visit(QT, nullptr, false);
11980 if ((NonTrivialKind & NTCUK_Destruct) &&
11982 DiagNonTrivalCUnionDestructedTypeVisitor(QT, Loc, UseContext, *this)
11983 .visit(QT, nullptr, false);
11984 if ((NonTrivialKind & NTCUK_Copy) && QT.hasNonTrivialToPrimitiveCopyCUnion())
11985 DiagNonTrivalCUnionCopyVisitor(QT, Loc, UseContext, *this)
11986 .visit(QT, nullptr, false);
11987}
11988
11989/// AddInitializerToDecl - Adds the initializer Init to the
11990/// declaration dcl. If DirectInit is true, this is C++ direct
11991/// initialization rather than copy initialization.
11992void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) {
11993 // If there is no declaration, there was an error parsing it. Just ignore
11994 // the initializer.
11995 if (!RealDecl || RealDecl->isInvalidDecl()) {
11996 CorrectDelayedTyposInExpr(Init, dyn_cast_or_null<VarDecl>(RealDecl));
11997 return;
11998 }
11999
12000 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
12001 // Pure-specifiers are handled in ActOnPureSpecifier.
12002 Diag(Method->getLocation(), diag::err_member_function_initialization)
12003 << Method->getDeclName() << Init->getSourceRange();
12004 Method->setInvalidDecl();
12005 return;
12006 }
12007
12008 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
12009 if (!VDecl) {
12010 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
12011 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
12012 RealDecl->setInvalidDecl();
12013 return;
12014 }
12015
12016 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
12017 if (VDecl->getType()->isUndeducedType()) {
12018 // Attempt typo correction early so that the type of the init expression can
12019 // be deduced based on the chosen correction if the original init contains a
12020 // TypoExpr.
12021 ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl);
12022 if (!Res.isUsable()) {
12023 // There are unresolved typos in Init, just drop them.
12024 // FIXME: improve the recovery strategy to preserve the Init.
12025 RealDecl->setInvalidDecl();
12026 return;
12027 }
12028 if (Res.get()->containsErrors()) {
12029 // Invalidate the decl as we don't know the type for recovery-expr yet.
12030 RealDecl->setInvalidDecl();
12031 VDecl->setInit(Res.get());
12032 return;
12033 }
12034 Init = Res.get();
12035
12036 if (DeduceVariableDeclarationType(VDecl, DirectInit, Init))
12037 return;
12038 }
12039
12040 // dllimport cannot be used on variable definitions.
12041 if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) {
12042 Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition);
12043 VDecl->setInvalidDecl();
12044 return;
12045 }
12046
12047 if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) {
12048 // C99 6.7.8p5. C++ has no such restriction, but that is a defect.
12049 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
12050 VDecl->setInvalidDecl();
12051 return;
12052 }
12053
12054 if (!VDecl->getType()->isDependentType()) {
12055 // A definition must end up with a complete type, which means it must be
12056 // complete with the restriction that an array type might be completed by
12057 // the initializer; note that later code assumes this restriction.
12058 QualType BaseDeclType = VDecl->getType();
12059 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
12060 BaseDeclType = Array->getElementType();
12061 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
12062 diag::err_typecheck_decl_incomplete_type)) {
12063 RealDecl->setInvalidDecl();
12064 return;
12065 }
12066
12067 // The variable can not have an abstract class type.
12068 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
12069 diag::err_abstract_type_in_decl,
12071 VDecl->setInvalidDecl();
12072 }
12073
12074 // If adding the initializer will turn this declaration into a definition,
12075 // and we already have a definition for this variable, diagnose or otherwise
12076 // handle the situation.
12077 VarDecl *Def;
12078 if ((Def = VDecl->getDefinition()) && Def != VDecl &&
12079 (!VDecl->isStaticDataMember() || VDecl->isOutOfLine()) &&
12081 checkVarDeclRedefinition(Def, VDecl))
12082 return;
12083
12084 if (getLangOpts().CPlusPlus) {
12085 // C++ [class.static.data]p4
12086 // If a static data member is of const integral or const
12087 // enumeration type, its declaration in the class definition can
12088 // specify a constant-initializer which shall be an integral
12089 // constant expression (5.19). In that case, the member can appear
12090 // in integral constant expressions. The member shall still be
12091 // defined in a namespace scope if it is used in the program and the
12092 // namespace scope definition shall not contain an initializer.
12093 //
12094 // We already performed a redefinition check above, but for static
12095 // data members we also need to check whether there was an in-class
12096 // declaration with an initializer.
12097 if (VDecl->isStaticDataMember() && VDecl->getCanonicalDecl()->hasInit()) {
12098 Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
12099 << VDecl->getDeclName();
12100 Diag(VDecl->getCanonicalDecl()->getInit()->getExprLoc(),
12101 diag::note_previous_initializer)
12102 << 0;
12103 return;
12104 }
12105
12106 if (VDecl->hasLocalStorage())
12108
12110 VDecl->setInvalidDecl();
12111 return;
12112 }
12113 }
12114
12115 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
12116 // a kernel function cannot be initialized."
12117 if (VDecl->getType().getAddressSpace() == LangAS::opencl_local) {
12118 Diag(VDecl->getLocation(), diag::err_local_cant_init);
12119 VDecl->setInvalidDecl();
12120 return;
12121 }
12122
12123 // The LoaderUninitialized attribute acts as a definition (of undef).
12124 if (VDecl->hasAttr<LoaderUninitializedAttr>()) {
12125 Diag(VDecl->getLocation(), diag::err_loader_uninitialized_cant_init);
12126 VDecl->setInvalidDecl();
12127 return;
12128 }
12129
12130 // Get the decls type and save a reference for later, since
12131 // CheckInitializerTypes may change it.
12132 QualType DclT = VDecl->getType(), SavT = DclT;
12133
12134 // Expressions default to 'id' when we're in a debugger
12135 // and we are assigning it to a variable of Objective-C pointer type.
12136 if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() &&
12137 Init->getType() == Context.UnknownAnyTy) {
12139 if (Result.isInvalid()) {
12140 VDecl->setInvalidDecl();
12141 return;
12142 }
12143 Init = Result.get();
12144 }
12145
12146 // Perform the initialization.
12147 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
12148 if (!VDecl->isInvalidDecl()) {
12151 VDecl->getLocation(), DirectInit, Init);
12152
12153 MultiExprArg Args = Init;
12154 if (CXXDirectInit)
12155 Args = MultiExprArg(CXXDirectInit->getExprs(),
12156 CXXDirectInit->getNumExprs());
12157
12158 // Try to correct any TypoExprs in the initialization arguments.
12159 for (size_t Idx = 0; Idx < Args.size(); ++Idx) {
12161 Args[Idx], VDecl, /*RecoverUncorrectedTypos=*/true,
12162 [this, Entity, Kind](Expr *E) {
12163 InitializationSequence Init(*this, Entity, Kind, MultiExprArg(E));
12164 return Init.Failed() ? ExprError() : E;
12165 });
12166 if (Res.isInvalid()) {
12167 VDecl->setInvalidDecl();
12168 } else if (Res.get() != Args[Idx]) {
12169 Args[Idx] = Res.get();
12170 }
12171 }
12172 if (VDecl->isInvalidDecl())
12173 return;
12174
12175 InitializationSequence InitSeq(*this, Entity, Kind, Args,
12176 /*TopLevelOfInitList=*/false,
12177 /*TreatUnavailableAsInvalid=*/false);
12178 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
12179 if (Result.isInvalid()) {
12180 // If the provied initializer fails to initialize the var decl,
12181 // we attach a recovery expr for better recovery.
12182 auto RecoveryExpr =
12183 CreateRecoveryExpr(Init->getBeginLoc(), Init->getEndLoc(), Args);
12184 if (RecoveryExpr.get())
12185 VDecl->setInit(RecoveryExpr.get());
12186 return;
12187 }
12188
12189 Init = Result.getAs<Expr>();
12190 }
12191
12192 // Check for self-references within variable initializers.
12193 // Variables declared within a function/method body (except for references)
12194 // are handled by a dataflow analysis.
12195 // This is undefined behavior in C++, but valid in C.
12196 if (getLangOpts().CPlusPlus) {
12197 if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() ||
12198 VDecl->getType()->isReferenceType()) {
12199 CheckSelfReference(*this, RealDecl, Init, DirectInit);
12200 }
12201 }
12202
12203 // If the type changed, it means we had an incomplete type that was
12204 // completed by the initializer. For example:
12205 // int ary[] = { 1, 3, 5 };
12206 // "ary" transitions from an IncompleteArrayType to a ConstantArrayType.
12207 if (!VDecl->isInvalidDecl() && (DclT != SavT))
12208 VDecl->setType(DclT);
12209
12210 if (!VDecl->isInvalidDecl()) {
12211 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
12212
12213 if (VDecl->hasAttr<BlocksAttr>())
12214 checkRetainCycles(VDecl, Init);
12215
12216 // It is safe to assign a weak reference into a strong variable.
12217 // Although this code can still have problems:
12218 // id x = self.weakProp;
12219 // id y = self.weakProp;
12220 // we do not warn to warn spuriously when 'x' and 'y' are on separate
12221 // paths through the function. This should be revisited if
12222 // -Wrepeated-use-of-weak is made flow-sensitive.
12223 if (FunctionScopeInfo *FSI = getCurFunction())
12224 if ((VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong ||
12226 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
12227 Init->getBeginLoc()))
12228 FSI->markSafeWeakUse(Init);
12229 }
12230
12231 // The initialization is usually a full-expression.
12232 //
12233 // FIXME: If this is a braced initialization of an aggregate, it is not
12234 // an expression, and each individual field initializer is a separate
12235 // full-expression. For instance, in:
12236 //
12237 // struct Temp { ~Temp(); };
12238 // struct S { S(Temp); };
12239 // struct T { S a, b; } t = { Temp(), Temp() }
12240 //
12241 // we should destroy the first Temp before constructing the second.
12243 ActOnFinishFullExpr(Init, VDecl->getLocation(),
12244 /*DiscardedValue*/ false, VDecl->isConstexpr());
12245 if (Result.isInvalid()) {
12246 VDecl->setInvalidDecl();
12247 return;
12248 }
12249 Init = Result.get();
12250
12251 // Attach the initializer to the decl.
12252 VDecl->setInit(Init);
12253
12254 if (VDecl->isLocalVarDecl()) {
12255 // Don't check the initializer if the declaration is malformed.
12256 if (VDecl->isInvalidDecl()) {
12257 // do nothing
12258
12259 // OpenCL v1.2 s6.5.3: __constant locals must be constant-initialized.
12260 // This is true even in C++ for OpenCL.
12261 } else if (VDecl->getType().getAddressSpace() == LangAS::opencl_constant) {
12262 CheckForConstantInitializer(Init, DclT);
12263
12264 // Otherwise, C++ does not restrict the initializer.
12265 } else if (getLangOpts().CPlusPlus) {
12266 // do nothing
12267
12268 // C99 6.7.8p4: All the expressions in an initializer for an object that has
12269 // static storage duration shall be constant expressions or string literals.
12270 } else if (VDecl->getStorageClass() == SC_Static) {
12271 CheckForConstantInitializer(Init, DclT);
12272
12273 // C89 is stricter than C99 for aggregate initializers.
12274 // C89 6.5.7p3: All the expressions [...] in an initializer list
12275 // for an object that has aggregate or union type shall be
12276 // constant expressions.
12277 } else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() &&
12278 isa<InitListExpr>(Init)) {
12279 const Expr *Culprit;
12280 if (!Init->isConstantInitializer(Context, false, &Culprit)) {
12281 Diag(Culprit->getExprLoc(),
12282 diag::ext_aggregate_init_not_constant)
12283 << Culprit->getSourceRange();
12284 }
12285 }
12286
12287 if (auto *E = dyn_cast<ExprWithCleanups>(Init))
12288 if (auto *BE = dyn_cast<BlockExpr>(E->getSubExpr()->IgnoreParens()))
12289 if (VDecl->hasLocalStorage())
12290 BE->getBlockDecl()->setCanAvoidCopyToHeap();
12291 } else if (VDecl->isStaticDataMember() && !VDecl->isInline() &&
12292 VDecl->getLexicalDeclContext()->isRecord()) {
12293 // This is an in-class initialization for a static data member, e.g.,
12294 //
12295 // struct S {
12296 // static const int value = 17;
12297 // };
12298
12299 // C++ [class.mem]p4:
12300 // A member-declarator can contain a constant-initializer only
12301 // if it declares a static member (9.4) of const integral or
12302 // const enumeration type, see 9.4.2.
12303 //
12304 // C++11 [class.static.data]p3:
12305 // If a non-volatile non-inline const static data member is of integral
12306 // or enumeration type, its declaration in the class definition can
12307 // specify a brace-or-equal-initializer in which every initializer-clause
12308 // that is an assignment-expression is a constant expression. A static
12309 // data member of literal type can be declared in the class definition
12310 // with the constexpr specifier; if so, its declaration shall specify a
12311 // brace-or-equal-initializer in which every initializer-clause that is
12312 // an assignment-expression is a constant expression.
12313
12314 // Do nothing on dependent types.
12315 if (DclT->isDependentType()) {
12316
12317 // Allow any 'static constexpr' members, whether or not they are of literal
12318 // type. We separately check that every constexpr variable is of literal
12319 // type.
12320 } else if (VDecl->isConstexpr()) {
12321
12322 // Require constness.
12323 } else if (!DclT.isConstQualified()) {
12324 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
12325 << Init->getSourceRange();
12326 VDecl->setInvalidDecl();
12327
12328 // We allow integer constant expressions in all cases.
12329 } else if (DclT->isIntegralOrEnumerationType()) {
12330 // Check whether the expression is a constant expression.
12331 SourceLocation Loc;
12333 // In C++11, a non-constexpr const static data member with an
12334 // in-class initializer cannot be volatile.
12335 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
12336 else if (Init->isValueDependent())
12337 ; // Nothing to check.
12338 else if (Init->isIntegerConstantExpr(Context, &Loc))
12339 ; // Ok, it's an ICE!
12340 else if (Init->getType()->isScopedEnumeralType() &&
12341 Init->isCXX11ConstantExpr(Context))
12342 ; // Ok, it is a scoped-enum constant expression.
12343 else if (Init->isEvaluatable(Context)) {
12344 // If we can constant fold the initializer through heroics, accept it,
12345 // but report this as a use of an extension for -pedantic.
12346 Diag(Loc, diag::ext_in_class_initializer_non_constant)
12347 << Init->getSourceRange();
12348 } else {
12349 // Otherwise, this is some crazy unknown case. Report the issue at the
12350 // location provided by the isIntegerConstantExpr failed check.
12351 Diag(Loc, diag::err_in_class_initializer_non_constant)
12352 << Init->getSourceRange();
12353 VDecl->setInvalidDecl();
12354 }
12355
12356 // We allow foldable floating-point constants as an extension.
12357 } else if (DclT->isFloatingType()) { // also permits complex, which is ok
12358 // In C++98, this is a GNU extension. In C++11, it is not, but we support
12359 // it anyway and provide a fixit to add the 'constexpr'.
12360 if (getLangOpts().CPlusPlus11) {
12361 Diag(VDecl->getLocation(),
12362 diag::ext_in_class_initializer_float_type_cxx11)
12363 << DclT << Init->getSourceRange();
12364 Diag(VDecl->getBeginLoc(),
12365 diag::note_in_class_initializer_float_type_cxx11)
12366 << FixItHint::CreateInsertion(VDecl->getBeginLoc(), "constexpr ");
12367 } else {
12368 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
12369 << DclT << Init->getSourceRange();
12370
12371 if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) {
12372 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
12373 << Init->getSourceRange();
12374 VDecl->setInvalidDecl();
12375 }
12376 }
12377
12378 // Suggest adding 'constexpr' in C++11 for literal types.
12379 } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) {
12380 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
12381 << DclT << Init->getSourceRange()
12382 << FixItHint::CreateInsertion(VDecl->getBeginLoc(), "constexpr ");
12383 VDecl->setConstexpr(true);
12384
12385 } else {
12386 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
12387 << DclT << Init->getSourceRange();
12388 VDecl->setInvalidDecl();
12389 }
12390 } else if (VDecl->isFileVarDecl()) {
12391 // In C, extern is typically used to avoid tentative definitions when
12392 // declaring variables in headers, but adding an intializer makes it a
12393 // definition. This is somewhat confusing, so GCC and Clang both warn on it.
12394 // In C++, extern is often used to give implictly static const variables
12395 // external linkage, so don't warn in that case. If selectany is present,
12396 // this might be header code intended for C and C++ inclusion, so apply the
12397 // C++ rules.
12398 if (VDecl->getStorageClass() == SC_Extern &&
12399 ((!getLangOpts().CPlusPlus && !VDecl->hasAttr<SelectAnyAttr>()) ||
12401 !(getLangOpts().CPlusPlus && VDecl->isExternC()) &&
12403 Diag(VDecl->getLocation(), diag::warn_extern_init);
12404
12405 // In Microsoft C++ mode, a const variable defined in namespace scope has
12406 // external linkage by default if the variable is declared with
12407 // __declspec(dllexport).
12410 VDecl->hasAttr<DLLExportAttr>() && VDecl->getDefinition())
12411 VDecl->setStorageClass(SC_Extern);
12412
12413 // C99 6.7.8p4. All file scoped initializers need to be constant.
12414 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
12415 CheckForConstantInitializer(Init, DclT);
12416 }
12417
12418 QualType InitType = Init->getType();
12419 if (!InitType.isNull() &&
12422 checkNonTrivialCUnionInInitializer(Init, Init->getExprLoc());
12423
12424 // We will represent direct-initialization similarly to copy-initialization:
12425 // int x(1); -as-> int x = 1;
12426 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
12427 //
12428 // Clients that want to distinguish between the two forms, can check for
12429 // direct initializer using VarDecl::getInitStyle().
12430 // A major benefit is that clients that don't particularly care about which
12431 // exactly form was it (like the CodeGen) can handle both cases without
12432 // special case code.
12433
12434 // C++ 8.5p11:
12435 // The form of initialization (using parentheses or '=') is generally
12436 // insignificant, but does matter when the entity being initialized has a
12437 // class type.
12438 if (CXXDirectInit) {
12439 assert(DirectInit && "Call-style initializer must be direct init.");
12441 } else if (DirectInit) {
12442 // This must be list-initialization. No other way is direct-initialization.
12444 }
12445
12446 if (LangOpts.OpenMP && VDecl->isFileVarDecl())
12447 DeclsToCheckForDeferredDiags.push_back(VDecl);
12449}
12450
12451/// ActOnInitializerError - Given that there was an error parsing an
12452/// initializer for the given declaration, try to return to some form
12453/// of sanity.
12455 // Our main concern here is re-establishing invariants like "a
12456 // variable's type is either dependent or complete".
12457 if (!D || D->isInvalidDecl()) return;
12458
12459 VarDecl *VD = dyn_cast<VarDecl>(D);
12460 if (!VD) return;
12461
12462 // Bindings are not usable if we can't make sense of the initializer.
12463 if (auto *DD = dyn_cast<DecompositionDecl>(D))
12464 for (auto *BD : DD->bindings())
12465 BD->setInvalidDecl();
12466
12467 // Auto types are meaningless if we can't make sense of the initializer.
12468 if (VD->getType()->isUndeducedType()) {
12469 D->setInvalidDecl();
12470 return;
12471 }
12472
12473 QualType Ty = VD->getType();
12474 if (Ty->isDependentType()) return;
12475
12476 // Require a complete type.
12479 diag::err_typecheck_decl_incomplete_type)) {
12480 VD->setInvalidDecl();
12481 return;
12482 }
12483
12484 // Require a non-abstract type.
12485 if (RequireNonAbstractType(VD->getLocation(), Ty,
12486 diag::err_abstract_type_in_decl,
12488 VD->setInvalidDecl();
12489 return;
12490 }
12491
12492 // Don't bother complaining about constructors or destructors,
12493 // though.
12494}
12495
12497 // If there is no declaration, there was an error parsing it. Just ignore it.
12498 if (!RealDecl)
12499 return;
12500
12501 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
12502 QualType Type = Var->getType();
12503
12504 // C++1z [dcl.dcl]p1 grammar implies that an initializer is mandatory.
12505 if (isa<DecompositionDecl>(RealDecl)) {
12506 Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var;
12507 Var->setInvalidDecl();
12508 return;
12509 }
12510
12511 if (Type->isUndeducedType() &&
12512 DeduceVariableDeclarationType(Var, false, nullptr))
12513 return;
12514
12515 // C++11 [class.static.data]p3: A static data member can be declared with
12516 // the constexpr specifier; if so, its declaration shall specify
12517 // a brace-or-equal-initializer.
12518 // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
12519 // the definition of a variable [...] or the declaration of a static data
12520 // member.
12521 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
12522 !Var->isThisDeclarationADemotedDefinition()) {
12523 if (Var->isStaticDataMember()) {
12524 // C++1z removes the relevant rule; the in-class declaration is always
12525 // a definition there.
12526 if (!getLangOpts().CPlusPlus17 &&
12528 Diag(Var->getLocation(),
12529 diag::err_constexpr_static_mem_var_requires_init)
12530 << Var;
12531 Var->setInvalidDecl();
12532 return;
12533 }
12534 } else {
12535 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
12536 Var->setInvalidDecl();
12537 return;
12538 }
12539 }
12540
12541 // OpenCL v1.1 s6.5.3: variables declared in the constant address space must
12542 // be initialized.
12543 if (!Var->isInvalidDecl() &&
12544 Var->getType().getAddressSpace() == LangAS::opencl_constant &&
12545 Var->getStorageClass() != SC_Extern && !Var->getInit()) {
12546 Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
12547 Var->setInvalidDecl();
12548 return;
12549 }
12550
12551 if (!Var->isInvalidDecl() && RealDecl->hasAttr<LoaderUninitializedAttr>()) {
12552 if (Var->getStorageClass() == SC_Extern) {
12553 Diag(Var->getLocation(), diag::err_loader_uninitialized_extern_decl)
12554 << Var;
12555 Var->setInvalidDecl();
12556 return;
12557 }
12558 if (RequireCompleteType(Var->getLocation(), Var->getType(),
12559 diag::err_typecheck_decl_incomplete_type)) {
12560 Var->setInvalidDecl();
12561 return;
12562 }
12563 if (CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
12564 if (!RD->hasTrivialDefaultConstructor()) {
12565 Diag(Var->getLocation(), diag::err_loader_uninitialized_trivial_ctor);
12566 Var->setInvalidDecl();
12567 return;
12568 }
12569 }
12570 }
12571
12572 VarDecl::DefinitionKind DefKind = Var->isThisDeclarationADefinition();
12573 if (!Var->isInvalidDecl() && DefKind != VarDecl::DeclarationOnly &&
12574 Var->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion())
12575 checkNonTrivialCUnion(Var->getType(), Var->getLocation(),
12577
12578
12579 switch (DefKind) {
12581 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
12582 break;
12583
12584 // We have an out-of-line definition of a static data member
12585 // that has an in-class initializer, so we type-check this like
12586 // a declaration.
12587 //
12588 LLVM_FALLTHROUGH;
12589
12591 // It's only a declaration.
12592
12593 // Block scope. C99 6.7p7: If an identifier for an object is
12594 // declared with no linkage (C99 6.2.2p6), the type for the
12595 // object shall be complete.
12596 if (!Type->isDependentType() && Var->isLocalVarDecl() &&
12597 !Var->hasLinkage() && !Var->isInvalidDecl() &&
12598 RequireCompleteType(Var->getLocation(), Type,
12599 diag::err_typecheck_decl_incomplete_type))
12600 Var->setInvalidDecl();
12601
12602 // Make sure that the type is not abstract.
12603 if (!Type->isDependentType() && !Var->isInvalidDecl() &&
12604 RequireNonAbstractType(Var->getLocation(), Type,
12605 diag::err_abstract_type_in_decl,
12607 Var->setInvalidDecl();
12608 if (!Type->isDependentType() && !Var->isInvalidDecl() &&
12609 Var->getStorageClass() == SC_PrivateExtern) {
12610 Diag(Var->getLocation(), diag::warn_private_extern);
12611 Diag(Var->getLocation(), diag::note_private_extern);
12612 }
12613
12615 !Var->isInvalidDecl() && !getLangOpts().CPlusPlus)
12616 ExternalDeclarations.push_back(Var);
12617
12618 return;
12619
12621 // File scope. C99 6.9.2p2: A declaration of an identifier for an
12622 // object that has file scope without an initializer, and without a
12623 // storage-class specifier or with the storage-class specifier "static",
12624 // constitutes a tentative definition. Note: A tentative definition with
12625 // external linkage is valid (C99 6.2.2p5).
12626 if (!Var->isInvalidDecl()) {
12627 if (const IncompleteArrayType *ArrayT
12630 Var->getLocation(), ArrayT->getElementType(),
12631 diag::err_array_incomplete_or_sizeless_type))
12632 Var->setInvalidDecl();
12633 } else if (Var->getStorageClass() == SC_Static) {
12634 // C99 6.9.2p3: If the declaration of an identifier for an object is
12635 // a tentative definition and has internal linkage (C99 6.2.2p3), the
12636 // declared type shall not be an incomplete type.
12637 // NOTE: code such as the following
12638 // static struct s;
12639 // struct s { int a; };
12640 // is accepted by gcc. Hence here we issue a warning instead of
12641 // an error and we do not invalidate the static declaration.
12642 // NOTE: to avoid multiple warnings, only check the first declaration.
12643 if (Var->isFirstDecl())
12644 RequireCompleteType(Var->getLocation(), Type,
12645 diag::ext_typecheck_decl_incomplete_type);
12646 }
12647 }
12648
12649 // Record the tentative definition; we're done.
12650 if (!Var->isInvalidDecl())
12652 return;
12653 }
12654
12655 // Provide a specific diagnostic for uninitialized variable
12656 // definitions with incomplete array type.
12657 if (Type->isIncompleteArrayType()) {
12658 Diag(Var->getLocation(),
12659 diag::err_typecheck_incomplete_array_needs_initializer);
12660 Var->setInvalidDecl();
12661 return;
12662 }
12663
12664 // Provide a specific diagnostic for uninitialized variable
12665 // definitions with reference type.
12666 if (Type->isReferenceType()) {
12667 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
12668 << Var << SourceRange(Var->getLocation(), Var->getLocation());
12669 Var->setInvalidDecl();
12670 return;
12671 }
12672
12673 // Do not attempt to type-check the default initializer for a
12674 // variable with dependent type.
12675 if (Type->isDependentType())
12676 return;
12677
12678 if (Var->isInvalidDecl())
12679 return;
12680
12681 if (!Var->hasAttr<AliasAttr>()) {
12682 if (RequireCompleteType(Var->getLocation(),
12684 diag::err_typecheck_decl_incomplete_type)) {
12685 Var->setInvalidDecl();
12686 return;
12687 }
12688 } else {
12689 return;
12690 }
12691
12692 // The variable can not have an abstract class type.
12693 if (RequireNonAbstractType(Var->getLocation(), Type,
12694 diag::err_abstract_type_in_decl,
12696 Var->setInvalidDecl();
12697 return;
12698 }
12699
12700 // Check for jumps past the implicit initializer. C++0x
12701 // clarifies that this applies to a "variable with automatic
12702 // storage duration", not a "local variable".
12703 // C++11 [stmt.dcl]p3
12704 // A program that jumps from a point where a variable with automatic
12705 // storage duration is not in scope to a point where it is in scope is
12706 // ill-formed unless the variable has scalar type, class type with a
12707 // trivial default constructor and a trivial destructor, a cv-qualified
12708 // version of one of these types, or an array of one of the preceding
12709 // types and is declared without an initializer.
12710 if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
12711 if (const RecordType *Record
12713 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
12714 // Mark the function (if we're in one) for further checking even if the
12715 // looser rules of C++11 do not require such checks, so that we can
12716 // diagnose incompatibilities with C++98.
12717 if (!CXXRecord->isPOD())
12719 }
12720 }
12721 // In OpenCL, we can't initialize objects in the __local address space,
12722 // even implicitly, so don't synthesize an implicit initializer.
12723 if (getLangOpts().OpenCL &&
12724 Var->getType().getAddressSpace() == LangAS::opencl_local)
12725 return;
12726 // C++03 [dcl.init]p9:
12727 // If no initializer is specified for an object, and the
12728 // object is of (possibly cv-qualified) non-POD class type (or
12729 // array thereof), the object shall be default-initialized; if
12730 // the object is of const-qualified type, the underlying class
12731 // type shall have a user-declared default
12732 // constructor. Otherwise, if no initializer is specified for
12733 // a non- static object, the object and its subobjects, if
12734 // any, have an indeterminate initial value); if the object
12735 // or any of its subobjects are of const-qualified type, the
12736 // program is ill-formed.
12737 // C++0x [dcl.init]p11:
12738 // If no initializer is specified for an object, the object is
12739 // default-initialized; [...].
12742 = InitializationKind::CreateDefault(Var->getLocation());
12743
12744 InitializationSequence InitSeq(*this, Entity, Kind, None);
12745 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
12746
12747 if (Init.get()) {
12748 Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
12749 // This is important for template substitution.
12750 Var->setInitStyle(VarDecl::CallInit);
12751 } else if (Init.isInvalid()) {
12752 // If default-init fails, attach a recovery-expr initializer to track
12753 // that initialization was attempted and failed.
12754 auto RecoveryExpr =
12755 CreateRecoveryExpr(Var->getLocation(), Var->getLocation(), {});
12756 if (RecoveryExpr.get())
12757 Var->setInit(RecoveryExpr.get());
12758 }
12759
12761 }
12762}
12763
12765 // If there is no declaration, there was an error parsing it. Ignore it.
12766 if (!D)
12767 return;
12768
12769 VarDecl *VD = dyn_cast<VarDecl>(D);
12770 if (!VD) {
12771 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
12772 D->setInvalidDecl();
12773 return;
12774 }
12775
12776 VD->setCXXForRangeDecl(true);
12777
12778 // for-range-declaration cannot be given a storage class specifier.
12779 int Error = -1;
12780 switch (VD->getStorageClass()) {
12781 case SC_None:
12782 break;
12783 case SC_Extern:
12784 Error = 0;
12785 break;
12786 case SC_Static:
12787 Error = 1;
12788 break;
12789 case SC_PrivateExtern:
12790 Error = 2;
12791 break;
12792 case SC_Auto:
12793 Error = 3;
12794 break;
12795 case SC_Register:
12796 Error = 4;
12797 break;
12798 }
12799
12800 // for-range-declaration cannot be given a storage class specifier con't.
12801 switch (VD->getTSCSpec()) {
12802 case TSCS_thread_local:
12803 Error = 6;
12804 break;
12805 case TSCS___thread:
12806 case TSCS__Thread_local:
12807 case TSCS_unspecified:
12808 break;
12809 }
12810
12811 if (Error != -1) {
12812 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
12813 << VD << Error;
12814 D->setInvalidDecl();
12815 }
12816}
12817
12820 IdentifierInfo *Ident,
12821 ParsedAttributes &Attrs,
12822 SourceLocation AttrEnd) {
12823 // C++1y [stmt.iter]p1:
12824 // A range-based for statement of the form
12825 // for ( for-range-identifier : for-range-initializer ) statement
12826 // is equivalent to
12827 // for ( auto&& for-range-identifier : for-range-initializer ) statement
12828 DeclSpec DS(Attrs.getPool().getFactory());
12829
12830 const char *PrevSpec;
12831 unsigned DiagID;
12832 DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID,
12834
12836 D.SetIdentifier(Ident, IdentLoc);
12837 D.takeAttributes(Attrs, AttrEnd);
12838
12839 D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/ false),
12840 IdentLoc);
12841 Decl *Var = ActOnDeclarator(S, D);
12842 cast<VarDecl>(Var)->setCXXForRangeDecl(true);
12844 return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc,
12845 AttrEnd.isValid() ? AttrEnd : IdentLoc);
12846}
12847
12849 if (var->isInvalidDecl()) return;
12850
12851 if (getLangOpts().OpenCL) {
12852 // OpenCL v2.0 s6.12.5 - Every block variable declaration must have an
12853 // initialiser
12854 if (var->getTypeSourceInfo()->getType()->isBlockPointerType() &&
12855 !var->hasInit()) {
12856 Diag(var->getLocation(), diag::err_opencl_invalid_block_declaration)
12857 << 1 /*Init*/;
12858 var->setInvalidDecl();
12859 return;
12860 }
12861 }
12862
12863 // In Objective-C, don't allow jumps past the implicit initialization of a
12864 // local retaining variable.
12865 if (getLangOpts().ObjC &&
12866 var->hasLocalStorage()) {
12867 switch (var->getType().getObjCLifetime()) {
12871 break;
12872
12876 break;
12877 }
12878 }
12879
12880 if (var->hasLocalStorage() &&
12883
12884 // Warn about externally-visible variables being defined without a
12885 // prior declaration. We only want to do this for global
12886 // declarations, but we also specifically need to avoid doing it for
12887 // class members because the linkage of an anonymous class can
12888 // change if it's later given a typedef name.
12889 if (var->isThisDeclarationADefinition() &&
12891 var->isExternallyVisible() && var->hasLinkage() &&
12892 !var->isInline() && !var->getDescribedVarTemplate() &&
12893 !isa<VarTemplatePartialSpecializationDecl>(var) &&
12895 !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
12896 var->getLocation())) {
12897 // Find a previous declaration that's not a definition.
12898 VarDecl *prev = var->getPreviousDecl();
12899 while (prev && prev->isThisDeclarationADefinition())
12900 prev = prev->getPreviousDecl();
12901
12902 if (!prev) {
12903 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
12904 Diag(var->getTypeSpecStartLoc(), diag::note_static_for_internal_linkage)
12905 << /* variable */ 0;
12906 }
12907 }
12908
12909 // Cache the result of checking for constant initialization.
12910 Optional<bool> CacheHasConstInit;
12911 const Expr *CacheCulprit = nullptr;
12912 auto checkConstInit = [&]() mutable {
12913 if (!CacheHasConstInit)
12914 CacheHasConstInit = var->getInit()->isConstantInitializer(
12915 Context, var->getType()->isReferenceType(), &CacheCulprit);
12916 return *CacheHasConstInit;
12917 };
12918
12919 if (var->getTLSKind() == VarDecl::TLS_Static) {
12920 if (var->getType().isDestructedType()) {
12921 // GNU C++98 edits for __thread, [basic.start.term]p3:
12922 // The type of an object with thread storage duration shall not
12923 // have a non-trivial destructor.
12924 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
12926 Diag(var->getLocation(), diag::note_use_thread_local);
12927 } else if (getLangOpts().CPlusPlus && var->hasInit()) {
12928 if (!checkConstInit()) {
12929 // GNU C++98 edits for __thread, [basic.start.init]p4:
12930 // An object of thread storage duration shall not require dynamic
12931 // initialization.
12932 // FIXME: Need strict checking here.
12933 Diag(CacheCulprit->getExprLoc(), diag::err_thread_dynamic_init)
12934 << CacheCulprit->getSourceRange();
12936 Diag(var->getLocation(), diag::note_use_thread_local);
12937 }
12938 }
12939 }
12940
12941 // Apply section attributes and pragmas to global variables.
12942 bool GlobalStorage = var->hasGlobalStorage();
12943 if (GlobalStorage && var->isThisDeclarationADefinition() &&
12945 PragmaStack<StringLiteral *> *Stack = nullptr;
12946 int SectionFlags = ASTContext::PSF_Read;
12947 if (var->getType().isConstQualified())
12948 Stack = &ConstSegStack;
12949 else if (!var->getInit()) {
12950 Stack = &BSSSegStack;
12951 SectionFlags |= ASTContext::PSF_Write;
12952 } else {
12953 Stack = &DataSegStack;
12954 SectionFlags |= ASTContext::PSF_Write;
12955 }
12956 if (const SectionAttr *SA = var->getAttr<SectionAttr>()) {
12957 if (SA->getSyntax() == AttributeCommonInfo::AS_Declspec)
12958 SectionFlags |= ASTContext::PSF_Implicit;
12959 UnifySection(SA->getName(), SectionFlags, var);
12960 } else if (Stack->CurrentValue) {
12961 SectionFlags |= ASTContext::PSF_Implicit;
12962 auto SectionName = Stack->CurrentValue->getString();
12964 Context, SectionName, Stack->CurrentPragmaLocation,
12966 if (UnifySection(SectionName, SectionFlags, var))
12967 var->dropAttr<SectionAttr>();
12968 }
12969
12970 // Apply the init_seg attribute if this has an initializer. If the
12971 // initializer turns out to not be dynamic, we'll end up ignoring this
12972 // attribute.
12973 if (CurInitSeg && var->getInit())
12977 }
12978
12979 if (!var->getType()->isStructureType() && var->hasInit() &&
12980 isa<InitListExpr>(var->getInit())) {
12981 const auto *ILE = cast<InitListExpr>(var->getInit());
12982 unsigned NumInits = ILE->getNumInits();
12983 if (NumInits > 2)
12984 for (unsigned I = 0; I < NumInits; ++I) {
12985 const auto *Init = ILE->getInit(I);
12986 if (!Init)
12987 break;
12988 const auto *SL = dyn_cast<StringLiteral>(Init->IgnoreImpCasts());
12989 if (!SL)
12990 break;
12991
12992 unsigned NumConcat = SL->getNumConcatenated();
12993 // Diagnose missing comma in string array initialization.
12994 // Do not warn when all the elements in the initializer are concatenated
12995 // together. Do not warn for macros too.
12996 if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) {
12997 bool OnlyOneMissingComma = true;
12998 for (unsigned J = I + 1; J < NumInits; ++J) {
12999 const auto *Init = ILE->getInit(J);
13000 if (!Init)
13001 break;
13002 const auto *SLJ = dyn_cast<StringLiteral>(Init->IgnoreImpCasts());
13003 if (!SLJ || SLJ->getNumConcatenated() > 1) {
13004 OnlyOneMissingComma = false;
13005 break;
13006 }
13007 }
13008
13009 if (OnlyOneMissingComma) {
13011 for (unsigned i = 0; i < NumConcat - 1; ++i)
13012 Hints.push_back(FixItHint::CreateInsertion(
13013 PP.getLocForEndOfToken(SL->getStrTokenLoc(i)), ","));
13014
13015 Diag(SL->getStrTokenLoc(1),
13016 diag::warn_concatenated_literal_array_init)
13017 << Hints;
13018 Diag(SL->getBeginLoc(),
13019 diag::note_concatenated_string_literal_silence);
13020 }
13021 // In any case, stop now.
13022 break;
13023 }
13024 }
13025 }
13026
13027 // All the following checks are C++ only.
13028 if (!getLangOpts().CPlusPlus) {
13029 // If this variable must be emitted, add it as an initializer for the
13030 // current module.
13031 if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty())
13032 Context.addModuleInitializer(ModuleScopes.back().Module, var);
13033 return;
13034 }
13035
13036 QualType type = var->getType();
13037
13038 if (var->hasAttr<BlocksAttr>())
13040
13041 Expr *Init = var->getInit();
13042 bool IsGlobal = GlobalStorage && !var->isStaticLocal();
13043 QualType baseType = Context.getBaseElementType(type);
13044
13045 // Check whether the initializer is sufficiently constant.
13046 if (!type->isDependentType() && Init && !Init->isValueDependent() &&
13047 (GlobalStorage || var->isConstexpr() ||
13049 // If this variable might have a constant initializer or might be usable in
13050 // constant expressions, check whether or not it actually is now. We can't
13051 // do this lazily, because the result might depend on things that change
13052 // later, such as which constexpr functions happen to be defined.
13054 bool HasConstInit;
13055 if (!getLangOpts().CPlusPlus11) {
13056 // Prior to C++11, in contexts where a constant initializer is required,
13057 // the set of valid constant initializers is described by syntactic rules
13058 // in [expr.const]p2-6.
13059 // FIXME: Stricter checking for these rules would be useful for constinit /
13060 // -Wglobal-constructors.
13061 HasConstInit = checkConstInit();
13062
13063 // Compute and cache the constant value, and remember that we have a
13064 // constant initializer.
13065 if (HasConstInit) {
13066 (void)var->checkForConstantInitialization(Notes);
13067 Notes.clear();
13068 } else if (CacheCulprit) {
13069 Notes.emplace_back(CacheCulprit->getExprLoc(),
13070 PDiag(diag::note_invalid_subexpr_in_const_expr));
13071 Notes.back().second << CacheCulprit->getSourceRange();
13072 }
13073 } else {
13074 // Evaluate the initializer to see if it's a constant initializer.
13075 HasConstInit = var->checkForConstantInitialization(Notes);
13076 }
13077
13078 if (HasConstInit) {
13079 // FIXME: Consider replacing the initializer with a ConstantExpr.
13080 } else if (var->isConstexpr()) {
13081 SourceLocation DiagLoc = var->getLocation();
13082 // If the note doesn't add any useful information other than a source
13083 // location, fold it into the primary diagnostic.
13084 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
13085 diag::note_invalid_subexpr_in_const_expr) {
13086 DiagLoc = Notes[0].first;
13087 Notes.clear();
13088 }
13089 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
13090 << var << Init->getSourceRange();
13091 for (unsigned I = 0, N = Notes.size(); I != N; ++I)
13092 Diag(Notes[I].first, Notes[I].second);
13093 } else if (GlobalStorage && var->hasAttr<ConstInitAttr>()) {
13094 auto *Attr = var->getAttr<ConstInitAttr>();
13095 Diag(var->getLocation(), diag::err_require_constant_init_failed)
13096 << Init->getSourceRange();
13097 Diag(Attr->getLocation(), diag::note_declared_required_constant_init_here)
13098 << Attr->getRange() << Attr->isConstinit();
13099 for (auto &it : Notes)
13100 Diag(it.first, it.second);
13101 } else if (IsGlobal &&
13102 !getDiagnostics().isIgnored(diag::warn_global_constructor,
13103 var->getLocation())) {
13104 // Warn about globals which don't have a constant initializer. Don't
13105 // warn about globals with a non-trivial destructor because we already
13106 // warned about them.
13107 CXXRecordDecl *RD = baseType->getAsCXXRecordDecl();
13108 if (!(RD && !RD->hasTrivialDestructor())) {
13109 // checkConstInit() here permits trivial default initialization even in
13110 // C++11 onwards, where such an initializer is not a constant initializer
13111 // but nonetheless doesn't require a global constructor.
13112 if (!checkConstInit())
13113 Diag(var->getLocation(), diag::warn_global_constructor)
13114 << Init->getSourceRange();
13115 }
13116 }
13117 }
13118
13119 // Require the destructor.
13120 if (!type->isDependentType())
13121 if (const RecordType *recordType = baseType->getAs<RecordType>())
13123
13124 // If this variable must be emitted, add it as an initializer for the current
13125 // module.
13126 if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty())
13127 Context.addModuleInitializer(ModuleScopes.back().Module, var);
13128
13129 // Build the bindings if this is a structured binding declaration.
13130 if (auto *DD = dyn_cast<DecompositionDecl>(var))
13132}
13133
13134/// Determines if a variable's alignment is dependent.
13136 if (VD->getType()->isDependentType())
13137 return true;
13138 for (auto *I : VD->specific_attrs<AlignedAttr>())
13139 if (I->isAlignmentDependent())
13140 return true;
13141 return false;
13142}
13143
13144/// Check if VD needs to be dllexport/dllimport due to being in a
13145/// dllexport/import function.
13147 assert(VD->isStaticLocal());
13148
13149 auto *FD = dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod());
13150
13151 // Find outermost function when VD is in lambda function.
13152 while (FD && !getDLLAttr(FD) &&
13155 FD = dyn_cast_or_null<FunctionDecl>(FD->getParentFunctionOrMethod());
13156 }
13157
13158 if (!FD)
13159 return;
13160
13161 // Static locals inherit dll attributes from their function.
13162 if (Attr *A = getDLLAttr(FD)) {
13163 auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext()));
13164 NewAttr->setInherited(true);
13165 VD->addAttr(NewAttr);
13166 } else if (Attr *A = FD->getAttr<DLLExportStaticLocalAttr>()) {
13167 auto *NewAttr = DLLExportAttr::CreateImplicit(getASTContext(), *A);
13168 NewAttr->setInherited(true);
13169 VD->addAttr(NewAttr);
13170
13171 // Export this function to enforce exporting this static variable even
13172 // if it is not used in this compilation unit.
13173 if (!FD->hasAttr<DLLExportAttr>())
13174 FD->addAttr(NewAttr);
13175
13176 } else if (Attr *A = FD->getAttr<DLLImportStaticLocalAttr>()) {
13177 auto *NewAttr = DLLImportAttr::CreateImplicit(getASTContext(), *A);
13178 NewAttr->setInherited(true);
13179 VD->addAttr(NewAttr);
13180 }
13181}
13182
13183/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
13184/// any semantic actions necessary after any initializer has been attached.
13186 // Note that we are no longer parsing the initializer for this declaration.
13187 ParsingInitForAutoVars.erase(ThisDecl);
13188
13189 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
13190 if (!VD)
13191 return;
13192
13193 // Apply an implicit SectionAttr if '#pragma clang section bss|data|rodata' is active
13216 }
13217
13218 if (auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) {
13219 for (auto *BD : DD->bindings()) {
13221 }
13222 }
13223
13224 checkAttributesAfterMerging(*this, *VD);
13225
13226 // Perform TLS alignment check here after attributes attached to the variable
13227 // which may affect the alignment have been processed. Only perform the check
13228 // if the target has a maximum TLS alignment (zero means no constraints).
13229 if (unsigned MaxAlign = Context.getTargetInfo().getMaxTLSAlign()) {
13230 // Protect the check so that it's not performed on dependent types and
13231 // dependent alignments (we can't determine the alignment in that case).
13232 if (VD->getTLSKind() && !hasDependentAlignment(VD) &&
13233 !VD->isInvalidDecl()) {
13234 CharUnits MaxAlignChars = Context.toCharUnitsFromBits(MaxAlign);
13235 if (Context.getDeclAlign(VD) > MaxAlignChars) {
13236 Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
13238 << (unsigned)MaxAlignChars.getQuantity();
13239 }
13240 }
13241 }
13242
13243 if (VD->isStaticLocal())
13245
13246 // Perform check for initializers of device-side global variables.
13247 // CUDA allows empty constructors as initializers (see E.2.3.1, CUDA
13248 // 7.5). We must also apply the same checks to all __shared__
13249 // variables whether they are local or not. CUDA also allows
13250 // constant initializers for __constant__ and __device__ variables.
13251 if (getLangOpts().CUDA)
13253
13254 // Grab the dllimport or dllexport attribute off of the VarDecl.
13255 const InheritableAttr *DLLAttr = getDLLAttr(VD);
13256
13257 // Imported static data members cannot be defined out-of-line.
13258 if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
13259 if (VD->isStaticDataMember() && VD->isOutOfLine() &&
13261 // We allow definitions of dllimport class template static data members
13262 // with a warning.
13265 bool IsClassTemplateMember =
13267 Context->getDescribedClassTemplate();
13268
13269 Diag(VD->getLocation(),
13270 IsClassTemplateMember
13271 ? diag::warn_attribute_dllimport_static_field_definition
13272 : diag::err_attribute_dllimport_static_field_definition);
13273 Diag(IA->getLocation(), diag::note_attribute);
13274 if (!IsClassTemplateMember)
13275 VD->setInvalidDecl();
13276 }
13277 }
13278
13279 // dllimport/dllexport variables cannot be thread local, their TLS index
13280 // isn't exported with the variable.
13281 if (DLLAttr && VD->getTLSKind()) {
13282 auto *F = dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod());
13283 if (F && getDLLAttr(F)) {
13284 assert(VD->isStaticLocal());
13285 // But if this is a static local in a dlimport/dllexport function, the
13286 // function will never be inlined, which means the var would never be
13287 // imported, so having it marked import/export is safe.
13288 } else {
13289 Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD
13290 << DLLAttr;
13291 VD->setInvalidDecl();
13292 }
13293 }
13294
13295 if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {
13296 if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {
13297 Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr;
13298 VD->dropAttr<UsedAttr>();
13299 }
13300 }
13301
13302 const DeclContext *DC = VD->getDeclContext();
13303 // If there's a #pragma GCC visibility in scope, and this isn't a class
13304 // member, set the visibility of this variable.
13307
13308 // FIXME: Warn on unused var template partial specializations.
13309 if (VD->isFileVarDecl() && !isa<VarTemplatePartialSpecializationDecl>(VD))
13311
13312 // Now we have parsed the initializer and can update the table of magic
13313 // tag values.
13314 if (!VD->hasAttr<TypeTagForDatatypeAttr>() ||
13316 return;
13317
13318 for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) {
13319 const Expr *MagicValueExpr = VD->getInit();
13320 if (!MagicValueExpr) {
13321 continue;
13322 }
13323 Optional<llvm::APSInt> MagicValueInt;
13324 if (!(MagicValueInt = MagicValueExpr->getIntegerConstantExpr(Context))) {
13325 Diag(I->getRange().getBegin(),
13326 diag::err_type_tag_for_datatype_not_ice)
13327 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
13328 continue;
13329 }
13330 if (MagicValueInt->getActiveBits() > 64) {
13331 Diag(I->getRange().getBegin(),
13332 diag::err_type_tag_for_datatype_too_large)
13333 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
13334 continue;
13335 }
13336 uint64_t MagicValue = MagicValueInt->getZExtValue();
13337 RegisterTypeTagForDatatype(I->getArgumentKind(),
13338 MagicValue,
13339 I->getMatchingCType(),
13340 I->getLayoutCompatible(),
13341 I->getMustBeNull());
13342 }
13343}
13344
13346 auto *VD = dyn_cast<VarDecl>(DD);
13347 return VD && !VD->getType()->hasAutoForTrailingReturnType();
13348}
13349
13351 ArrayRef<Decl *> Group) {
13353
13354 if (DS.isTypeSpecOwned())
13355 Decls.push_back(DS.getRepAsDecl());
13356
13357 DeclaratorDecl *FirstDeclaratorInGroup = nullptr;
13358 DecompositionDecl *FirstDecompDeclaratorInGroup = nullptr;
13359 bool DiagnosedMultipleDecomps = false;
13360 DeclaratorDecl *FirstNonDeducedAutoInGroup = nullptr;
13361 bool DiagnosedNonDeducedAuto = false;
13362
13363 for (unsigned i = 0, e = Group.size(); i != e; ++i) {
13364 if (Decl *D = Group[i]) {
13365 // For declarators, there are some additional syntactic-ish checks we need
13366 // to perform.
13367 if (auto *DD = dyn_cast<DeclaratorDecl>(D)) {
13368 if (!FirstDeclaratorInGroup)
13369 FirstDeclaratorInGroup = DD;
13370 if (!FirstDecompDeclaratorInGroup)
13371 FirstDecompDeclaratorInGroup = dyn_cast<DecompositionDecl>(D);
13372 if (!FirstNonDeducedAutoInGroup && DS.hasAutoTypeSpec() &&
13373 !hasDeducedAuto(DD))
13374 FirstNonDeducedAutoInGroup = DD;
13375
13376 if (FirstDeclaratorInGroup != DD) {
13377 // A decomposition declaration cannot be combined with any other
13378 // declaration in the same group.
13379 if (FirstDecompDeclaratorInGroup && !DiagnosedMultipleDecomps) {
13380 Diag(FirstDecompDeclaratorInGroup->getLocation(),
13381 diag::err_decomp_decl_not_alone)
13382 << FirstDeclaratorInGroup->getSourceRange()
13383 << DD->getSourceRange();
13384 DiagnosedMultipleDecomps = true;
13385 }
13386
13387 // A declarator that uses 'auto' in any way other than to declare a
13388 // variable with a deduced type cannot be combined with any other
13389 // declarator in the same group.
13390 if (FirstNonDeducedAutoInGroup && !DiagnosedNonDeducedAuto) {
13391 Diag(FirstNonDeducedAutoInGroup->getLocation(),
13392 diag::err_auto_non_deduced_not_alone)
13393 << FirstNonDeducedAutoInGroup->getType()
13395 << FirstDeclaratorInGroup->getSourceRange()
13396 << DD->getSourceRange();
13397 DiagnosedNonDeducedAuto = true;
13398 }
13399 }
13400 }
13401
13402 Decls.push_back(D);
13403 }
13404 }
13405
13407 if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) {
13408 handleTagNumbering(Tag, S);
13409 if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
13411 Context.addDeclaratorForUnnamedTagDecl(Tag, FirstDeclaratorInGroup);
13412 }
13413 }
13414
13415 return BuildDeclaratorGroup(Decls);
13416}
13417
13418/// BuildDeclaratorGroup - convert a list of declarations into a declaration
13419/// group, performing any necessary semantic checking.
13422 // C++14 [dcl.spec.auto]p7: (DR1347)
13423 // If the type that replaces the placeholder type is not the same in each
13424 // deduction, the program is ill-formed.
13425 if (Group.size() > 1) {
13426 QualType Deduced;
13427 VarDecl *DeducedDecl = nullptr;
13428 for (unsigned i = 0, e = Group.size(); i != e; ++i) {
13429 VarDecl *D = dyn_cast<VarDecl>(Group[i]);
13430 if (!D || D->isInvalidDecl())
13431 break;
13433 if (!DT || DT->getDeducedType().isNull())
13434 continue;
13435 if (Deduced.isNull()) {
13436 Deduced = DT->getDeducedType();
13437 DeducedDecl = D;
13438 } else if (!Context.hasSameType(DT->getDeducedType(), Deduced)) {
13439 auto *AT = dyn_cast<AutoType>(DT);
13440 auto Dia = Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
13441 diag::err_auto_different_deductions)
13442 << (AT ? (unsigned)AT->getKeyword() : 3) << Deduced
13443 << DeducedDecl->getDeclName() << DT->getDeducedType()
13444 << D->getDeclName();
13445 if (DeducedDecl->hasInit())
13446 Dia << DeducedDecl->getInit()->getSourceRange();
13447 if (D->getInit())
13448 Dia << D->getInit()->getSourceRange();
13449 D->setInvalidDecl();
13450 break;
13451 }
13452 }
13453 }
13454
13456
13457 return DeclGroupPtrTy::make(
13458 DeclGroupRef::Create(Context, Group.data(), Group.size()));
13459}
13460
13464
13466 // Don't parse the comment if Doxygen diagnostics are ignored.
13467 if (Group.empty() || !Group[0])
13468 return;
13469
13470 if (Diags.isIgnored(diag::warn_doc_param_not_found,
13471 Group[0]->getLocation()) &&
13472 Diags.isIgnored(diag::warn_unknown_comment_command_name,
13473 Group[0]->getLocation()))
13474 return;
13475
13476 if (Group.size() >= 2) {
13477 // This is a decl group. Normally it will contain only declarations
13478 // produced from declarator list. But in case we have any definitions or
13479 // additional declaration references:
13480 // 'typedef struct S {} S;'
13481 // 'typedef struct S *S;'
13482 // 'struct S *pS;'
13483 // FinalizeDeclaratorGroup adds these as separate declarations.
13484 Decl *MaybeTagDecl = Group[0];
13485 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
13486 Group = Group.slice(1);
13487 }
13488 }
13489
13490 // FIMXE: We assume every Decl in the group is in the same file.
13491 // This is false when preprocessor constructs the group from decls in
13492 // different files (e. g. macros or #include).
13494}
13495
13496/// Common checks for a parameter-declaration that should apply to both function
13497/// parameters and non-type template parameters.
13499 // Check that there are no default arguments inside the type of this
13500 // parameter.
13501 if (getLangOpts().CPlusPlus)
13503
13504 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
13505 if (D.getCXXScopeSpec().isSet()) {
13506 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
13507 << D.getCXXScopeSpec().getRange();
13508 }
13509
13510 // [dcl.meaning]p1: An unqualified-id occurring in a declarator-id shall be a
13511 // simple identifier except [...irrelevant cases...].
13512 switch (D.getName().getKind()) {
13514 break;
13515
13523 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
13525 break;
13526
13529 // GetNameForDeclarator would not produce a useful name in this case.
13530 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name_template_id);
13531 break;
13532 }
13533}
13534
13535/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
13536/// to introduce parameters into function prototype scope.
13538 const DeclSpec &DS = D.getDeclSpec();
13539
13540 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
13541
13542 // C++03 [dcl.stc]p2 also permits 'auto'.
13543 StorageClass SC = SC_None;
13545 SC = SC_Register;
13546 // In C++11, the 'register' storage class specifier is deprecated.
13547 // In C++17, it is not allowed, but we tolerate it as an extension.
13548 if (getLangOpts().CPlusPlus11) {
13550 getLangOpts().CPlusPlus17 ? diag::ext_register_storage_class
13551 : diag::warn_deprecated_register)
13553 }
13554 } else if (getLangOpts().CPlusPlus &&
13556 SC = SC_Auto;
13559 diag::err_invalid_storage_class_in_func_decl);
13561 }
13562
13564 Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
13566 if (DS.isInlineSpecified())
13567 Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
13568 << getLangOpts().CPlusPlus17;
13569 if (DS.hasConstexprSpecifier())
13570 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
13571 << 0 << static_cast<int>(D.getDeclSpec().getConstexprSpecifier());
13572
13574
13576
13577 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13578 QualType parmDeclType = TInfo->getType();
13579
13580 // Check for redeclaration of parameters, e.g. int foo(int x, int x);
13581 IdentifierInfo *II = D.getIdentifier();
13582 if (II) {
13585 LookupName(R, S);
13586 if (R.isSingleResult()) {
13587 NamedDecl *PrevDecl = R.getFoundDecl();
13588 if (PrevDecl->isTemplateParameter()) {
13589 // Maybe we will complain about the shadowed template parameter.
13591 // Just pretend that we didn't see the previous declaration.
13592 PrevDecl = nullptr;
13593 } else if (S->isDeclScope(PrevDecl)) {
13594 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
13595 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
13596
13597 // Recover by removing the name
13598 II = nullptr;
13599 D.SetIdentifier(nullptr, D.getIdentifierLoc());
13600 D.setInvalidType(true);
13601 }
13602 }
13603 }
13604
13605 // Temporarily put parameter variables in the translation unit, not
13606 // the enclosing context. This prevents them from accidentally
13607 // looking like class members in C++.
13608 ParmVarDecl *New =
13610 D.getIdentifierLoc(), II, parmDeclType, TInfo, SC);
13611
13612 if (D.isInvalidType())
13613 New->setInvalidDecl();
13614
13615 assert(S->isFunctionPrototypeScope());
13616 assert(S->getFunctionPrototypeDepth() >= 1);
13617 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1,
13618 S->getNextFunctionPrototypeIndex());
13619
13620 // Add the parameter declaration into this scope.
13621 S->AddDecl(New);
13622 if (II)
13623 IdResolver.AddDecl(New);
13624
13625 ProcessDeclAttributes(S, New, D);
13626
13628 Diag(New->getLocation(), diag::err_module_private_local)
13629 << 1 << New << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
13631
13632 if (New->hasAttr<BlocksAttr>()) {
13633 Diag(New->getLocation(), diag::err_block_on_nonlocal);
13634 }
13635
13636 if (getLangOpts().OpenCL)
13638
13639 return New;
13640}
13641
13642/// Synthesizes a variable for a parameter arising from a
13643/// typedef.
13645 SourceLocation Loc,
13646 QualType T) {
13647 /* FIXME: setting StartLoc == Loc.
13648 Would it be worth to modify callers so as to provide proper source
13649 location for the unnamed parameters, embedding the parameter's type? */
13650 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr,
13652 SC_None, nullptr);
13653 Param->setImplicit();
13654 return Param;
13655}
13656
13658 // Don't diagnose unused-parameter errors in template instantiations; we
13659 // will already have done so in the template itself.
13661 return;
13662
13663 for (const ParmVarDecl *Parameter : Parameters) {
13664 if (!Parameter->isReferenced() && Parameter->getDeclName() &&
13665 !Parameter->hasAttr<UnusedAttr>()) {
13666 Diag(Parameter->getLocation(), diag::warn_unused_parameter)
13667 << Parameter->getDeclName();
13668 }
13669 }
13670}
13671
13673 ArrayRef<ParmVarDecl *> Parameters, QualType ReturnTy, NamedDecl *D) {
13674 if (LangOpts.NumLargeByValueCopy == 0) // No check.
13675 return;
13676
13677 // Warn if the return value is pass-by-value and larger than the specified
13678 // threshold.
13679 if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) {
13680 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
13681 if (Size > LangOpts.NumLargeByValueCopy)
13682 Diag(D->getLocation(), diag::warn_return_value_size) << D << Size;
13683 }
13684
13685 // Warn if any parameter is pass-by-value and larger than the specified
13686 // threshold.
13687 for (const ParmVarDecl *Parameter : Parameters) {
13688 QualType T = Parameter->getType();
13689 if (T->isDependentType() || !T.isPODType(Context))
13690 continue;
13691 unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
13692 if (Size > LangOpts.NumLargeByValueCopy)
13693 Diag(Parameter->getLocation(), diag::warn_parameter_size)
13694 << Parameter << Size;
13695 }
13696}
13697
13699 SourceLocation NameLoc, IdentifierInfo *Name,
13700 QualType T, TypeSourceInfo *TSInfo,
13701 StorageClass SC) {
13702 // In ARC, infer a lifetime qualifier for appropriate parameter types.
13703 if (getLangOpts().ObjCAutoRefCount &&
13704 T.getObjCLifetime() == Qualifiers::OCL_None &&
13705 T->isObjCLifetimeType()) {
13706
13707 Qualifiers::ObjCLifetime lifetime;
13708
13709 // Special cases for arrays:
13710 // - if it's const, use __unsafe_unretained
13711 // - otherwise, it's an error
13712 if (T->isArrayType()) {
13713 if (!T.isConstQualified()) {
13717 NameLoc, diag::err_arc_array_param_no_ownership, T, false));
13718 else
13719 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
13720 << TSInfo->getTypeLoc().getSourceRange();
13721 }
13723 } else {
13724 lifetime = T->getObjCARCImplicitLifetime();
13725 }
13726 T = Context.getLifetimeQualifiedType(T, lifetime);
13727 }
13728
13729 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
13731 TSInfo, SC, nullptr);
13732
13733 // Make a note if we created a new pack in the scope of a lambda, so that
13734 // we know that references to that pack must also be expanded within the
13735 // lambda scope.
13736 if (New->isParameterPack())
13737 if (auto *LSI = getEnclosingLambda())
13738 LSI->LocalPacks.push_back(New);
13739
13744
13745 // Parameters can not be abstract class types.
13746 // For record types, this is done by the AbstractClassUsageDiagnoser once
13747 // the class has been completely parsed.
13748 if (!CurContext->isRecord() &&
13749 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
13751 New->setInvalidDecl();
13752
13753 // Parameter declarators cannot be interface types. All ObjC objects are
13754 // passed by reference.
13755 if (T->isObjCObjectType()) {
13756 SourceLocation TypeEndLoc =
13758 Diag(NameLoc,
13759 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
13760 << FixItHint::CreateInsertion(TypeEndLoc, "*");
13762 New->setType(T);
13763 }
13764
13765 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
13766 // duration shall not be qualified by an address-space qualifier."
13767 // Since all parameters have automatic store duration, they can not have
13768 // an address space.
13769 if (T.getAddressSpace() != LangAS::Default &&
13770 // OpenCL allows function arguments declared to be an array of a type
13771 // to be qualified with an address space.
13772 !(getLangOpts().OpenCL &&
13773 (T->isArrayType() || T.getAddressSpace() == LangAS::opencl_private))) {
13774 Diag(NameLoc, diag::err_arg_with_address_space);
13775 New->setInvalidDecl();
13776 }
13777
13778 // PPC MMA non-pointer types are not allowed as function argument types.
13779 if (Context.getTargetInfo().getTriple().isPPC64() &&
13780 CheckPPCMMAType(New->getOriginalType(), New->getLocation())) {
13781 New->setInvalidDecl();
13782 }
13783
13784 return New;
13785}
13786
13788 SourceLocation LocAfterDecls) {
13790
13791 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
13792 // for a K&R function.
13793 if (!FTI.hasPrototype) {
13794 for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
13795 --i;
13796 if (FTI.Params[i].Param == nullptr) {
13797 SmallString<256> Code;
13798 llvm::raw_svector_ostream(Code)
13799 << " int " << FTI.Params[i].Ident->getName() << ";\n";
13800 Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
13801 << FTI.Params[i].Ident
13802 << FixItHint::CreateInsertion(LocAfterDecls, Code);
13803
13804 // Implicitly declare the argument as type 'int' for lack of a better
13805 // type.
13806 AttributeFactory attrs;
13807 DeclSpec DS(attrs);
13808 const char* PrevSpec; // unused
13809 unsigned DiagID; // unused
13810 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
13811 DiagID, Context.getPrintingPolicy());
13812 // Use the identifier location for the type source range.
13813 DS.SetRangeStart(FTI.Params[i].IdentLoc);
13814 DS.SetRangeEnd(FTI.Params[i].IdentLoc);
13816 ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
13817 FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);
13818 }
13819 }
13820 }
13821}
13822
13823Decl *
13825 MultiTemplateParamsArg TemplateParameterLists,
13826 SkipBodyInfo *SkipBody) {
13827 assert(getCurFunctionDecl() == nullptr && "Function parsing confused");
13828 assert(D.isFunctionDeclarator() && "Not a function declarator!");
13829 Scope *ParentScope = FnBodyScope->getParent();
13830
13831 // Check if we are in an `omp begin/end declare variant` scope. If we are, and
13832 // we define a non-templated function definition, we will create a declaration
13833 // instead (=BaseFD), and emit the definition with a mangled name afterwards.
13834 // The base function declaration will have the equivalent of an `omp declare
13835 // variant` annotation which specifies the mangled definition as a
13836 // specialization function under the OpenMP context defined as part of the
13837 // `omp begin declare variant`.
13841 ParentScope, D, TemplateParameterLists, Bases);
13842
13844 Decl *DP = HandleDeclarator(ParentScope, D, TemplateParameterLists);
13845 Decl *Dcl = ActOnStartOfFunctionDef(FnBodyScope, DP, SkipBody);
13846
13847 if (!Bases.empty())
13849
13850 return Dcl;
13851}
13852
13856
13857static bool
13859 const FunctionDecl *&PossiblePrototype) {
13860 // Don't warn about invalid declarations.
13861 if (FD->isInvalidDecl())
13862 return false;
13863
13864 // Or declarations that aren't global.
13865 if (!FD->isGlobal())
13866 return false;
13867
13868 // Don't warn about C++ member functions.
13869 if (isa<CXXMethodDecl>(FD))
13870 return false;
13871
13872 // Don't warn about 'main'.
13873 if (isa<TranslationUnitDecl>(FD->getDeclContext()->getRedeclContext()))
13874 if (IdentifierInfo *II = FD->getIdentifier())
13875 if (II->isStr("main"))
13876 return false;
13877
13878 // Don't warn about inline functions.
13879 if (FD->isInlined())
13880 return false;
13881
13882 // Don't warn about function templates.
13884 return false;
13885
13886 // Don't warn about function template specializations.
13888 return false;
13889
13890 // Don't warn for OpenCL kernels.
13891 if (FD->hasAttr<OpenCLKernelAttr>())
13892 return false;
13893
13894 // Don't warn on explicitly deleted functions.
13895 if (FD->isDeleted())
13896 return false;
13897
13898 for (const FunctionDecl *Prev = FD->getPreviousDecl();
13899 Prev; Prev = Prev->getPreviousDecl()) {
13900 // Ignore any declarations that occur in function or method
13901 // scope, because they aren't visible from the header.
13902 if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
13903 continue;
13904
13905 PossiblePrototype = Prev;
13906 return Prev->getType()->isFunctionNoProtoType();
13907 }
13908
13909 return true;
13910}
13911
13912void
13914 const FunctionDecl *EffectiveDefinition,
13915 SkipBodyInfo *SkipBody) {
13916 const FunctionDecl *Definition = EffectiveDefinition;
13917 if (!Definition &&
13918 !FD->isDefined(Definition, /*CheckForPendingFriendDefinition*/ true))
13919 return;
13920
13921 if (Definition->getFriendObjectKind() != Decl::FOK_None) {
13923 if (FunctionDecl *OrigFD = FD->getInstantiatedFromMemberFunction()) {
13924 // A merged copy of the same function, instantiated as a member of
13925 // the same class, is OK.
13926 if (declaresSameEntity(OrigFD, OrigDef) &&
13927 declaresSameEntity(cast<Decl>(Definition->getLexicalDeclContext()),
13928 cast<Decl>(FD->getLexicalDeclContext())))
13929 return;
13930 }
13931 }
13932 }
13933
13935 return;
13936
13937 // Don't emit an error when this is redefinition of a typo-corrected
13938 // definition.
13940 return;
13941
13942 // If we don't have a visible definition of the function, and it's inline or
13943 // a template, skip the new definition.
13944 if (SkipBody && !hasVisibleDefinition(Definition) &&
13945 (Definition->getFormalLinkage() == InternalLinkage ||
13946 Definition->isInlined() ||
13947 Definition->getDescribedFunctionTemplate() ||
13948 Definition->getNumTemplateParameterLists())) {
13949 SkipBody->ShouldSkip = true;
13950 SkipBody->Previous = const_cast<FunctionDecl*>(Definition);
13951 if (auto *TD = Definition->getDescribedFunctionTemplate())
13954 return;
13955 }
13956
13957 if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
13958 Definition->getStorageClass() == SC_Extern)
13959 Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
13960 << FD << getLangOpts().CPlusPlus;
13961 else
13962 Diag(FD->getLocation(), diag::err_redefinition) << FD;
13963
13964 Diag(Definition->getLocation(), diag::note_previous_definition);
13965 FD->setInvalidDecl();
13966}
13967
13968static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator,
13969 Sema &S) {
13970 CXXRecordDecl *const LambdaClass = CallOperator->getParent();
13971
13973 LSI->CallOperator = CallOperator;
13974 LSI->Lambda = LambdaClass;
13975 LSI->ReturnType = CallOperator->getReturnType();
13976 const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
13977
13978 if (LCD == LCD_None)
13980 else if (LCD == LCD_ByCopy)
13982 else if (LCD == LCD_ByRef)
13984 DeclarationNameInfo DNI = CallOperator->getNameInfo();
13985
13987 LSI->Mutable = !CallOperator->isConst();
13988
13989 // Add the captures to the LSI so they can be noted as already
13990 // captured within tryCaptureVar.
13991 auto I = LambdaClass->field_begin();
13992 for (const auto &C : LambdaClass->captures()) {
13993 if (C.capturesVariable()) {
13994 VarDecl *VD = C.getCapturedVar();
13995 if (VD->isInitCapture())
13997 const bool ByRef = C.getCaptureKind() == LCK_ByRef;
13998 LSI->addCapture(VD, /*IsBlock*/false, ByRef,
13999 /*RefersToEnclosingVariableOrCapture*/true, C.getLocation(),
14000 /*EllipsisLoc*/C.isPackExpansion()
14001 ? C.getEllipsisLoc() : SourceLocation(),
14002 I->getType(), /*Invalid*/false);
14003
14004 } else if (C.capturesThis()) {
14005 LSI->addThisCapture(/*Nested*/ false, C.getLocation(), I->getType(),
14006 C.getCaptureKind() == LCK_StarThis);
14007 } else {
14008 LSI->addVLATypeCapture(C.getLocation(), I->getCapturedVLAType(),
14009 I->getType());
14010 }
14011 ++I;
14012 }
14013}
14014
14016 SkipBodyInfo *SkipBody) {
14017 if (!D) {
14018 // Parsing the function declaration failed in some way. Push on a fake scope
14019 // anyway so we can try to parse the function body.
14022 return D;
14023 }
14024
14025 FunctionDecl *FD = nullptr;
14026
14027 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
14028 FD = FunTmpl->getTemplatedDecl();
14029 else
14030 FD = cast<FunctionDecl>(D);
14031
14032 // Do not push if it is a lambda because one is already pushed when building
14033 // the lambda in ActOnStartOfLambdaDefinition().
14034 if (!isLambdaCallOperator(FD))
14037 : ExprEvalContexts.back().Context);
14038
14039 // Check for defining attributes before the check for redefinition.
14040 if (const auto *Attr = FD->getAttr<AliasAttr>()) {
14041 Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 0;
14042 FD->dropAttr<AliasAttr>();
14043 FD->setInvalidDecl();
14044 }
14045 if (const auto *Attr = FD->getAttr<IFuncAttr>()) {
14046 Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 1;
14047 FD->dropAttr<IFuncAttr>();
14048 FD->setInvalidDecl();
14049 }
14050
14051 if (auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
14052 if (Ctor->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
14053 Ctor->isDefaultConstructor() &&
14055 // If this is an MS ABI dllexport default constructor, instantiate any
14056 // default arguments.
14058 }
14059 }
14060
14061 // See if this is a redefinition. If 'will have body' (or similar) is already
14062 // set, then these checks were already performed when it was set.
14063 if (!FD->willHaveBody() && !FD->isLateTemplateParsed() &&
14065 CheckForFunctionRedefinition(FD, nullptr, SkipBody);
14066
14067 // If we're skipping the body, we're done. Don't enter the scope.
14068 if (SkipBody && SkipBody->ShouldSkip)
14069 return D;
14070 }
14071
14072 // Mark this function as "will have a body eventually". This lets users to
14073 // call e.g. isInlineDefinitionExternallyVisible while we're still parsing
14074 // this function.
14075 FD->setWillHaveBody();
14076
14077 // If we are instantiating a generic lambda call operator, push
14078 // a LambdaScopeInfo onto the function stack. But use the information
14079 // that's already been calculated (ActOnLambdaExpr) to prime the current
14080 // LambdaScopeInfo.
14081 // When the template operator is being specialized, the LambdaScopeInfo,
14082 // has to be properly restored so that tryCaptureVariable doesn't try
14083 // and capture any new variables. In addition when calculating potential
14084 // captures during transformation of nested lambdas, it is necessary to
14085 // have the LSI properly restored.
14087 assert(inTemplateInstantiation() &&
14088 "There should be an active template instantiation on the stack "
14089 "when instantiating a generic lambda!");
14090 RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this);
14091 } else {
14092 // Enter a new function scope
14094 }
14095
14096 // Builtin functions cannot be defined.
14097 if (unsigned BuiltinID = FD->getBuiltinID()) {
14100 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
14101 FD->setInvalidDecl();
14102 }
14103 }
14104
14105 // The return type of a function definition must be complete
14106 // (C99 6.9.1p3, C++ [dcl.fct]p6).
14107 QualType ResultType = FD->getReturnType();
14108 if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
14109 !FD->isInvalidDecl() &&
14110 RequireCompleteType(FD->getLocation(), ResultType,
14111 diag::err_func_def_incomplete_result))
14112 FD->setInvalidDecl();
14113
14114 if (FnBodyScope)
14115 PushDeclContext(FnBodyScope, FD);
14116
14117 // Check the validity of our function parameters
14119 /*CheckParameterNames=*/true);
14120
14121 // Add non-parameter declarations already in the function to the current
14122 // scope.
14123 if (FnBodyScope) {
14124 for (Decl *NPD : FD->decls()) {
14125 auto *NonParmDecl = dyn_cast<NamedDecl>(NPD);
14126 if (!NonParmDecl)
14127 continue;
14128 assert(!isa<ParmVarDecl>(NonParmDecl) &&
14129 "parameters should not be in newly created FD yet");
14130
14131 // If the decl has a name, make it accessible in the current scope.
14132 if (NonParmDecl->getDeclName())
14133 PushOnScopeChains(NonParmDecl, FnBodyScope, /*AddToContext=*/false);
14134
14135 // Similarly, dive into enums and fish their constants out, making them
14136 // accessible in this scope.
14137 if (auto *ED = dyn_cast<EnumDecl>(NonParmDecl)) {
14138 for (auto *EI : ED->enumerators())
14139 PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false);
14140 }
14141 }
14142 }
14143
14144 // Introduce our parameters into the function scope
14145 for (auto Param : FD->parameters()) {
14146 Param->setOwningFunction(FD);
14147
14148 // If this has an identifier, add it to the scope stack.
14149 if (Param->getIdentifier() && FnBodyScope) {
14150 CheckShadow(FnBodyScope, Param);
14151
14152 PushOnScopeChains(Param, FnBodyScope);
14153 }
14154 }
14155
14156 // Ensure that the function's exception specification is instantiated.
14157 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
14159
14160 // dllimport cannot be applied to non-inline function definitions.
14161 if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() &&
14162 !FD->isTemplateInstantiation()) {
14163 assert(!FD->hasAttr<DLLExportAttr>());
14164 Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
14165 FD->setInvalidDecl();
14166 return D;
14167 }
14168 // We want to attach documentation to original Decl (which might be
14169 // a function template).
14171 if (getCurLexicalContext()->isObjCContainer() &&
14172 getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
14173 getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation)
14174 Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
14175
14176 return D;
14177}
14178
14179/// Given the set of return statements within a function body,
14180/// compute the variables that are subject to the named return value
14181/// optimization.
14182///
14183/// Each of the variables that is subject to the named return value
14184/// optimization will be marked as NRVO variables in the AST, and any
14185/// return statement that has a marked NRVO variable as its NRVO candidate can
14186/// use the named return value optimization.
14187///
14188/// This function applies a very simplistic algorithm for NRVO: if every return
14189/// statement in the scope of a variable has the same NRVO candidate, that
14190/// candidate is an NRVO variable.
14192 ReturnStmt **Returns = Scope->Returns.data();
14193
14194 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
14195 if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
14196 if (!NRVOCandidate->isNRVOVariable())
14197 Returns[I]->setNRVOCandidate(nullptr);
14198 }
14199 }
14200}
14201
14203 // We can't delay parsing the body of a constexpr function template (yet).
14205 return false;
14206
14207 // We can't delay parsing the body of a function template with a deduced
14208 // return type (yet).
14209 if (D.getDeclSpec().hasAutoTypeSpec()) {
14210 // If the placeholder introduces a non-deduced trailing return type,
14211 // we can still delay parsing it.
14212 if (D.getNumTypeObjects()) {
14213 const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1);
14214 if (Outer.Kind == DeclaratorChunk::Function &&
14215 Outer.Fun.hasTrailingReturnType()) {
14216 QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType());
14217 return Ty.isNull() || !Ty->isUndeducedType();
14218 }
14219 }
14220 return false;
14221 }
14222
14223 return true;
14224}
14225
14227 // We cannot skip the body of a function (or function template) which is
14228 // constexpr, since we may need to evaluate its body in order to parse the
14229 // rest of the file.
14230 // We cannot skip the body of a function with an undeduced return type,
14231 // because any callers of that function need to know the type.
14232 if (const FunctionDecl *FD = D->getAsFunction()) {
14233 if (FD->isConstexpr())
14234 return false;
14235 // We can't simply call Type::isUndeducedType here, because inside template
14236 // auto can be deduced to a dependent type, which is not considered
14237 // "undeduced".
14238 if (FD->getReturnType()->getContainedDeducedType())
14239 return false;
14240 }
14242}
14243
14245 if (!Decl)
14246 return nullptr;
14247 if (FunctionDecl *FD = Decl->getAsFunction())
14248 FD->setHasSkippedBody();
14249 else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(Decl))
14250 MD->setHasSkippedBody();
14251 return Decl;
14252}
14253
14255 return ActOnFinishFunctionBody(D, BodyArg, false);
14256}
14257
14258/// RAII object that pops an ExpressionEvaluationContext when exiting a function
14259/// body.
14261public:
14262 ExitFunctionBodyRAII(Sema &S, bool IsLambda) : S(S), IsLambda(IsLambda) {}
14264 if (!IsLambda)
14266 }
14267
14268private:
14269 Sema &S;
14270 bool IsLambda = false;
14271};
14272
14274 llvm::DenseMap<const BlockDecl *, bool> EscapeInfo;
14275
14276 auto IsOrNestedInEscapingBlock = [&](const BlockDecl *BD) {
14277 if (EscapeInfo.count(BD))
14278 return EscapeInfo[BD];
14279
14280 bool R = false;
14281 const BlockDecl *CurBD = BD;
14282
14283 do {
14284 R = !CurBD->doesNotEscape();
14285 if (R)
14286 break;
14287 CurBD = CurBD->getParent()->getInnermostBlockDecl();
14288 } while (CurBD);
14289
14290 return EscapeInfo[BD] = R;
14291 };
14292
14293 // If the location where 'self' is implicitly retained is inside a escaping
14294 // block, emit a diagnostic.
14295 for (const std::pair<SourceLocation, const BlockDecl *> &P :
14297 if (IsOrNestedInEscapingBlock(P.second))
14298 S.Diag(P.first, diag::warn_implicitly_retains_self)
14299 << FixItHint::CreateInsertion(P.first, "self->");
14300}
14301
14303 bool IsInstantiation) {
14305 FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr;
14306
14307 if (FSI->UsesFPIntrin && !FD->hasAttr<StrictFPAttr>())
14309
14311 sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr;
14312
14313 if (getLangOpts().Coroutines && FSI->isCoroutine())
14315
14316 // Do not call PopExpressionEvaluationContext() if it is a lambda because one
14317 // is already popped when finishing the lambda in BuildLambdaExpr(). This is
14318 // meant to pop the context added in ActOnStartOfFunctionDef().
14319 ExitFunctionBodyRAII ExitRAII(*this, isLambdaCallOperator(FD));
14320
14321 if (FD) {
14322 FD->setBody(Body);
14323 FD->setWillHaveBody(false);
14324
14325 if (getLangOpts().CPlusPlus14) {
14326 if (!FD->isInvalidDecl() && Body && !FD->isDependentContext() &&
14327 FD->getReturnType()->isUndeducedType()) {
14328 // If the function has a deduced result type but contains no 'return'
14329 // statements, the result type as written must be exactly 'auto', and
14330 // the deduced result type is 'void'.
14331 if (!FD->getReturnType()->getAs<AutoType>()) {
14332 Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)
14333 << FD->getReturnType();
14334 FD->setInvalidDecl();
14335 } else {
14336 // Substitute 'void' for the 'auto' in the type.
14337 TypeLoc ResultType = getReturnTypeLoc(FD);
14339 FD, SubstAutoType(ResultType.getType(), Context.VoidTy));
14340 }
14341 }
14342 } else if (getLangOpts().CPlusPlus11 && isLambdaCallOperator(FD)) {
14343 // In C++11, we don't use 'auto' deduction rules for lambda call
14344 // operators because we don't support return type deduction.
14345 auto *LSI = getCurLambda();
14346 if (LSI->HasImplicitReturnType) {
14348
14349 // C++11 [expr.prim.lambda]p4:
14350 // [...] if there are no return statements in the compound-statement
14351 // [the deduced type is] the type void
14352 QualType RetType =
14353 LSI->ReturnType.isNull() ? Context.VoidTy : LSI->ReturnType;
14354
14355 // Update the return type to the deduced type.
14356 const auto *Proto = FD->getType()->castAs<FunctionProtoType>();
14357 FD->setType(Context.getFunctionType(RetType, Proto->getParamTypes(),
14358 Proto->getExtProtoInfo()));
14359 }
14360 }
14361
14362 // If the function implicitly returns zero (like 'main') or is naked,
14363 // don't complain about missing return statements.
14364 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
14366
14367 // MSVC permits the use of pure specifier (=0) on function definition,
14368 // defined at class scope, warn about this non-standard construct.
14369 if (getLangOpts().MicrosoftExt && FD->isPure() && !FD->isOutOfLine())
14370 Diag(FD->getLocation(), diag::ext_pure_function_definition);
14371
14372 if (!FD->isInvalidDecl()) {
14373 // Don't diagnose unused parameters of defaulted or deleted functions.
14374 if (!FD->isDeleted() && !FD->isDefaulted() && !FD->hasSkippedBody())
14377 FD->getReturnType(), FD);
14378
14379 // If this is a structor, we need a vtable.
14380 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
14381 MarkVTableUsed(FD->getLocation(), Constructor->getParent());
14382 else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(FD))
14383 MarkVTableUsed(FD->getLocation(), Destructor->getParent());
14384
14385 // Try to apply the named return value optimization. We have to check
14386 // if we can do this here because lambdas keep return statements around
14387 // to deduce an implicit return type.
14388 if (FD->getReturnType()->isRecordType() &&
14390 computeNRVO(Body, FSI);
14391 }
14392
14393 // GNU warning -Wmissing-prototypes:
14394 // Warn if a global function is defined without a previous
14395 // prototype declaration. This warning is issued even if the
14396 // definition itself provides a prototype. The aim is to detect
14397 // global functions that fail to be declared in header files.
14398 const FunctionDecl *PossiblePrototype = nullptr;
14399 if (ShouldWarnAboutMissingPrototype(FD, PossiblePrototype)) {
14400 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
14401
14402 if (PossiblePrototype) {
14403 // We found a declaration that is not a prototype,
14404 // but that could be a zero-parameter prototype
14405 if (TypeSourceInfo *TI = PossiblePrototype->getTypeSourceInfo()) {
14406 TypeLoc TL = TI->getTypeLoc();
14408 Diag(PossiblePrototype->getLocation(),
14409 diag::note_declaration_not_a_prototype)
14410 << (FD->getNumParams() != 0)
14411 << (FD->getNumParams() == 0
14412 ? FixItHint::CreateInsertion(FTL.getRParenLoc(), "void")
14413 : FixItHint{});
14414 }
14415 } else {
14416 // Returns true if the token beginning at this Loc is `const`.
14417 auto isLocAtConst = [&](SourceLocation Loc, const SourceManager &SM,
14418 const LangOptions &LangOpts) {
14419 std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc);
14420 if (LocInfo.first.isInvalid())
14421 return false;
14422
14423 bool Invalid = false;
14424 StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid);
14425 if (Invalid)
14426 return false;
14427
14428 if (LocInfo.second > Buffer.size())
14429 return false;
14430
14431 const char *LexStart = Buffer.data() + LocInfo.second;
14432 StringRef StartTok(LexStart, Buffer.size() - LocInfo.second);
14433
14434 return StartTok.consume_front("const") &&
14435 (StartTok.empty() || isWhitespace(StartTok[0]) ||
14436 StartTok.startswith("/*") || StartTok.startswith("//"));
14437 };
14438
14439 auto findBeginLoc = [&]() {
14440 // If the return type has `const` qualifier, we want to insert
14441 // `static` before `const` (and not before the typename).
14442 if ((FD->getReturnType()->isAnyPointerType() &&
14445 // But only do this if we can determine where the `const` is.
14446
14447 if (isLocAtConst(FD->getBeginLoc(), getSourceManager(),
14448 getLangOpts()))
14449
14450 return FD->getBeginLoc();
14451 }
14452 return FD->getTypeSpecStartLoc();
14453 };
14454 Diag(FD->getTypeSpecStartLoc(), diag::note_static_for_internal_linkage)
14455 << /* function */ 1
14456 << (FD->getStorageClass() == SC_None
14457 ? FixItHint::CreateInsertion(findBeginLoc(), "static ")
14458 : FixItHint{});
14459 }
14460
14461 // GNU warning -Wstrict-prototypes
14462 // Warn if K&R function is defined without a previous declaration.
14463 // This warning is issued only if the definition itself does not provide
14464 // a prototype. Only K&R definitions do not provide a prototype.
14465 if (!FD->hasWrittenPrototype()) {
14467 TypeLoc TL = TI->getTypeLoc();
14469 Diag(FTL.getLParenLoc(), diag::warn_strict_prototypes) << 2;
14470 }
14471 }
14472
14473 // Warn on CPUDispatch with an actual body.
14474 if (FD->isMultiVersion() && FD->hasAttr<CPUDispatchAttr>() && Body)
14475 if (const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
14476 if (!CmpndBody->body_empty())
14477 Diag(CmpndBody->body_front()->getBeginLoc(),
14478 diag::warn_dispatch_body_ignored);
14479
14480 if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
14481 const CXXMethodDecl *KeyFunction;
14482 if (MD->isOutOfLine() && (MD = MD->getCanonicalDecl()) &&
14483 MD->isVirtual() &&
14484 (KeyFunction = Context.getCurrentKeyFunction(MD->getParent())) &&
14485 MD == KeyFunction->getCanonicalDecl()) {
14486 // Update the key-function state if necessary for this ABI.
14487 if (FD->isInlined() &&
14490
14491 // If the newly-chosen key function is already defined, then we
14492 // need to mark the vtable as used retroactively.
14493 KeyFunction = Context.getCurrentKeyFunction(MD->getParent());
14494 const FunctionDecl *Definition;
14495 if (KeyFunction && KeyFunction->isDefined(Definition))
14496 MarkVTableUsed(Definition->getLocation(), MD->getParent(), true);
14497 } else {
14498 // We just defined they key function; mark the vtable as used.
14499 MarkVTableUsed(FD->getLocation(), MD->getParent(), true);
14500 }
14501 }
14502 }
14503
14504 assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) &&
14505 "Function parsing confused");
14506 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
14507 assert(MD == getCurMethodDecl() && "Method parsing confused");
14508 MD->setBody(Body);
14509 if (!MD->isInvalidDecl()) {
14511 MD->getReturnType(), MD);
14512
14513 if (Body)
14514 computeNRVO(Body, FSI);
14515 }
14516 if (FSI->ObjCShouldCallSuper) {
14517 Diag(MD->getEndLoc(), diag::warn_objc_missing_super_call)
14518 << MD->getSelector().getAsString();
14519 FSI->ObjCShouldCallSuper = false;
14520 }
14522 const ObjCMethodDecl *InitMethod = nullptr;
14523 bool isDesignated =
14524 MD->isDesignatedInitializerForTheInterface(&InitMethod);
14525 assert(isDesignated && InitMethod);
14526 (void)isDesignated;
14527
14528 auto superIsNSObject = [&](const ObjCMethodDecl *MD) {
14529 auto IFace = MD->getClassInterface();
14530 if (!IFace)
14531 return false;
14532 auto SuperD = IFace->getSuperClass();
14533 if (!SuperD)
14534 return false;
14535 return SuperD->getIdentifier() ==
14536 NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
14537 };
14538 // Don't issue this warning for unavailable inits or direct subclasses
14539 // of NSObject.
14540 if (!MD->isUnavailable() && !superIsNSObject(MD)) {
14541 Diag(MD->getLocation(),
14542 diag::warn_objc_designated_init_missing_super_call);
14543 Diag(InitMethod->getLocation(),
14544 diag::note_objc_designated_init_marked_here);
14545 }
14547 }
14548 if (FSI->ObjCWarnForNoInitDelegation) {
14549 // Don't issue this warning for unavaialable inits.
14550 if (!MD->isUnavailable())
14551 Diag(MD->getLocation(),
14552 diag::warn_objc_secondary_init_missing_init_call);
14553 FSI->ObjCWarnForNoInitDelegation = false;
14554 }
14555
14557 } else {
14558 // Parsing the function declaration failed in some way. Pop the fake scope
14559 // we pushed on.
14560 PopFunctionScopeInfo(ActivePolicy, dcl);
14561 return nullptr;
14562 }
14563
14564 if (Body && FSI->HasPotentialAvailabilityViolations)
14566
14567 assert(!FSI->ObjCShouldCallSuper &&
14568 "This should only be set for ObjC methods, which should have been "
14569 "handled in the block above.");
14570
14571 // Verify and clean out per-function state.
14572 if (Body && (!FD || !FD->isDefaulted())) {
14573 // C++ constructors that have function-try-blocks can't have return
14574 // statements in the handlers of that block. (C++ [except.handle]p14)
14575 // Verify this.
14576 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
14577 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
14578
14579 // Verify that gotos and switch cases don't jump into scopes illegally.
14580 if (FSI->NeedsScopeChecking() &&
14583
14584 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
14585 if (!Destructor->getParent()->isDependentType())
14586 CheckDestructor(Destructor);
14587
14588 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
14589 Destructor->getParent());
14590 }
14591
14592 // If any errors have occurred, clear out any temporaries that may have
14593 // been leftover. This ensures that these temporaries won't be picked up for
14594 // deletion in some later function.
14596 getDiagnostics().getSuppressAllDiagnostics()) {
14598 }
14600 !isa<FunctionTemplateDecl>(dcl)) {
14601 // Since the body is valid, issue any analysis-based warnings that are
14602 // enabled.
14603 ActivePolicy = &WP;
14604 }
14605
14606 if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
14608 FD->setInvalidDecl();
14609
14610 if (FD && FD->hasAttr<NakedAttr>()) {
14611 for (const Stmt *S : Body->children()) {
14612 // Allow local register variables without initializer as they don't
14613 // require prologue.
14614 bool RegisterVariables = false;
14615 if (auto *DS = dyn_cast<DeclStmt>(S)) {
14616 for (const auto *Decl : DS->decls()) {
14617 if (const auto *Var = dyn_cast<VarDecl>(Decl)) {
14618 RegisterVariables =
14619 Var->hasAttr<AsmLabelAttr>() && !Var->hasInit();
14620 if (!RegisterVariables)
14621 break;
14622 }
14623 }
14624 }
14625 if (RegisterVariables)
14626 continue;
14627 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
14628 Diag(S->getBeginLoc(), diag::err_non_asm_stmt_in_naked_function);
14629 Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
14630 FD->setInvalidDecl();
14631 break;
14632 }
14633 }
14634 }
14635
14636 assert(ExprCleanupObjects.size() ==
14637 ExprEvalContexts.back().NumCleanupObjects &&
14638 "Leftover temporaries in function");
14639 assert(!Cleanup.exprNeedsCleanups() && "Unaccounted cleanups in function");
14640 assert(MaybeODRUseExprs.empty() &&
14641 "Leftover expressions for odr-use checking");
14642 }
14643
14644 if (!IsInstantiation)
14646
14647 PopFunctionScopeInfo(ActivePolicy, dcl);
14648 // If any errors have occurred, clear out any temporaries that may have
14649 // been leftover. This ensures that these temporaries won't be picked up for
14650 // deletion in some later function.
14653 }
14654
14655 if (FD && (LangOpts.OpenMP || LangOpts.CUDA || LangOpts.SYCLIsDevice)) {
14656 auto ES = getEmissionStatus(FD);
14659 DeclsToCheckForDeferredDiags.push_back(FD);
14660 }
14661
14662 return dcl;
14663}
14664
14665/// When we finish delayed parsing of an attribute, we must attach it to the
14666/// relevant Decl.
14668 ParsedAttributes &Attrs) {
14669 // Always attach attributes to the underlying decl.
14670 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
14671 D = TD->getTemplatedDecl();
14672 ProcessDeclAttributeList(S, D, Attrs);
14673
14674 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
14675 if (Method->isStatic())
14677}
14678
14679/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
14680/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
14682 IdentifierInfo &II, Scope *S) {
14683 // Find the scope in which the identifier is injected and the corresponding
14684 // DeclContext.
14685 // FIXME: C89 does not say what happens if there is no enclosing block scope.
14686 // In that case, we inject the declaration into the translation unit scope
14687 // instead.
14688 Scope *BlockScope = S;
14689 while (!BlockScope->isCompoundStmtScope() && BlockScope->getParent())
14690 BlockScope = BlockScope->getParent();
14691
14692 Scope *ContextScope = BlockScope;
14693 while (!ContextScope->getEntity())
14694 ContextScope = ContextScope->getParent();
14695 ContextRAII SavedContext(*this, ContextScope->getEntity());
14696
14697 // Before we produce a declaration for an implicitly defined
14698 // function, see whether there was a locally-scoped declaration of
14699 // this name as a function or variable. If so, use that
14700 // (non-visible) declaration, and complain about it.
14701 NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II);
14702 if (ExternCPrev) {
14703 // We still need to inject the function into the enclosing block scope so
14704 // that later (non-call) uses can see it.
14705 PushOnScopeChains(ExternCPrev, BlockScope, /*AddToContext*/false);
14706
14707 // C89 footnote 38:
14708 // If in fact it is not defined as having type "function returning int",
14709 // the behavior is undefined.
14710 if (!isa<FunctionDecl>(ExternCPrev) ||
14712 cast<FunctionDecl>(ExternCPrev)->getType(),
14714 Diag(Loc, diag::ext_use_out_of_scope_declaration)
14715 << ExternCPrev << !getLangOpts().C99;
14716 Diag(ExternCPrev->getLocation(), diag::note_previous_declaration);
14717 return ExternCPrev;
14718 }
14719 }
14720
14721 // Extension in C99. Legal in C90, but warn about it.
14722 unsigned diag_id;
14723 if (II.getName().startswith("__builtin_"))
14724 diag_id = diag::warn_builtin_unknown;
14725 // OpenCL v2.0 s6.9.u - Implicit function declaration is not supported.
14726 else if (getLangOpts().OpenCL)
14727 diag_id = diag::err_opencl_implicit_function_decl;
14728 else if (getLangOpts().C99)
14729 diag_id = diag::ext_implicit_function_decl;
14730 else
14731 diag_id = diag::warn_implicit_function_decl;
14732 Diag(Loc, diag_id) << &II;
14733
14734 // If we found a prior declaration of this function, don't bother building
14735 // another one. We've already pushed that one into scope, so there's nothing
14736 // more to do.
14737 if (ExternCPrev)
14738 return ExternCPrev;
14739
14740 // Because typo correction is expensive, only do it if the implicit
14741 // function declaration is going to be treated as an error.
14742 if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
14743 TypoCorrection Corrected;
14745 if (S && (Corrected =
14747 S, nullptr, CCC, CTK_NonError)))
14748 diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion),
14749 /*ErrorRecovery*/false);
14750 }
14751
14752 // Set a Declarator for the implicit definition: int foo();
14753 const char *Dummy;
14754 AttributeFactory attrFactory;
14755 DeclSpec DS(attrFactory);
14756 unsigned DiagID;
14757 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
14759 (void)Error; // Silence warning.
14760 assert(!Error && "Error setting up implicit decl!");
14761 SourceLocation NoLoc;
14763 D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
14764 /*IsAmbiguous=*/false,
14765 /*LParenLoc=*/NoLoc,
14766 /*Params=*/nullptr,
14767 /*NumParams=*/0,
14768 /*EllipsisLoc=*/NoLoc,
14769 /*RParenLoc=*/NoLoc,
14770 /*RefQualifierIsLvalueRef=*/true,
14771 /*RefQualifierLoc=*/NoLoc,
14772 /*MutableLoc=*/NoLoc, EST_None,
14773 /*ESpecRange=*/SourceRange(),
14774 /*Exceptions=*/nullptr,
14775 /*ExceptionRanges=*/nullptr,
14776 /*NumExceptions=*/0,
14777 /*NoexceptExpr=*/nullptr,
14778 /*ExceptionSpecTokens=*/nullptr,
14779 /*DeclsInPrototype=*/None, Loc,
14780 Loc, D),
14781 std::move(DS.getAttributes()), SourceLocation());
14782 D.SetIdentifier(&II, Loc);
14783
14784 // Insert this function into the enclosing block scope.
14785 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(BlockScope, D));
14786 FD->setImplicit();
14787
14789
14790 return FD;
14791}
14792
14793/// If this function is a C++ replaceable global allocation function
14794/// (C++2a [basic.stc.dynamic.allocation], C++2a [new.delete]),
14795/// adds any function attributes that we know a priori based on the standard.
14796///
14797/// We need to check for duplicate attributes both here and where user-written
14798/// attributes are applied to declarations.
14800 FunctionDecl *FD) {
14801 if (FD->isInvalidDecl())
14802 return;
14803
14804 if (FD->getDeclName().getCXXOverloadedOperator() != OO_New &&
14805 FD->getDeclName().getCXXOverloadedOperator() != OO_Array_New)
14806 return;
14807
14808 Optional<unsigned> AlignmentParam;
14809 bool IsNothrow = false;
14810 if (!FD->isReplaceableGlobalAllocationFunction(&AlignmentParam, &IsNothrow))
14811 return;
14812
14813 // C++2a [basic.stc.dynamic.allocation]p4:
14814 // An allocation function that has a non-throwing exception specification
14815 // indicates failure by returning a null pointer value. Any other allocation
14816 // function never returns a null pointer value and indicates failure only by
14817 // throwing an exception [...]
14818 if (!IsNothrow && !FD->hasAttr<ReturnsNonNullAttr>())
14820
14821 // C++2a [basic.stc.dynamic.allocation]p2:
14822 // An allocation function attempts to allocate the requested amount of
14823 // storage. [...] If the request succeeds, the value returned by a
14824 // replaceable allocation function is a [...] pointer value p0 different
14825 // from any previously returned value p1 [...]
14826 //
14827 // However, this particular information is being added in codegen,
14828 // because there is an opt-out switch for it (-fno-assume-sane-operator-new)
14829
14830 // C++2a [basic.stc.dynamic.allocation]p2:
14831 // An allocation function attempts to allocate the requested amount of
14832 // storage. If it is successful, it returns the address of the start of a
14833 // block of storage whose length in bytes is at least as large as the
14834 // requested size.
14835 if (!FD->hasAttr<AllocSizeAttr>()) {
14837 Context, /*ElemSizeParam=*/ParamIdx(1, FD),
14838 /*NumElemsParam=*/ParamIdx(), FD->getLocation()));
14839 }
14840
14841 // C++2a [basic.stc.dynamic.allocation]p3:
14842 // For an allocation function [...], the pointer returned on a successful
14843 // call shall represent the address of storage that is aligned as follows:
14844 // (3.1) If the allocation function takes an argument of type
14845 // std​::​align_­val_­t, the storage will have the alignment
14846 // specified by the value of this argument.
14847 if (AlignmentParam.hasValue() && !FD->hasAttr<AllocAlignAttr>()) {
14849 Context, ParamIdx(AlignmentParam.getValue(), FD), FD->getLocation()));
14850 }
14851
14852 // FIXME:
14853 // C++2a [basic.stc.dynamic.allocation]p3:
14854 // For an allocation function [...], the pointer returned on a successful
14855 // call shall represent the address of storage that is aligned as follows:
14856 // (3.2) Otherwise, if the allocation function is named operator new[],
14857 // the storage is aligned for any object that does not have
14858 // new-extended alignment ([basic.align]) and is no larger than the
14859 // requested size.
14860 // (3.3) Otherwise, the storage is aligned for any object that does not
14861 // have new-extended alignment and is of the requested size.
14862}
14863
14864/// Adds any function attributes that we know a priori based on
14865/// the declaration of this function.
14866///
14867/// These attributes can apply both to implicitly-declared builtins
14868/// (like __builtin___printf_chk) or to library-declared functions
14869/// like NSLog or printf.
14870///
14871/// We need to check for duplicate attributes both here and where user-written
14872/// attributes are applied to declarations.
14874 if (FD->isInvalidDecl())
14875 return;
14876
14877 // If this is a built-in function, map its builtin attributes to
14878 // actual attributes.
14879 if (unsigned BuiltinID = FD->getBuiltinID()) {
14880 // Handle printf-formatting attributes.
14881 unsigned FormatIdx;
14882 bool HasVAListArg;
14883 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
14884 if (!FD->hasAttr<FormatAttr>()) {
14885 const char *fmt = "printf";
14886 unsigned int NumParams = FD->getNumParams();
14887 if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf)
14888 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
14889 fmt = "NSString";
14891 &Context.Idents.get(fmt),
14892 FormatIdx+1,
14893 HasVAListArg ? 0 : FormatIdx+2,
14894 FD->getLocation()));
14895 }
14896 }
14897 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
14898 HasVAListArg)) {
14899 if (!FD->hasAttr<FormatAttr>())
14901 &Context.Idents.get("scanf"),
14902 FormatIdx+1,
14903 HasVAListArg ? 0 : FormatIdx+2,
14904 FD->getLocation()));
14905 }
14906
14907 // Handle automatically recognized callbacks.
14908 SmallVector<int, 4> Encoding;
14909 if (!FD->hasAttr<CallbackAttr>() &&
14910 Context.BuiltinInfo.performsCallback(BuiltinID, Encoding))
14912 Context, Encoding.data(), Encoding.size(), FD->getLocation()));
14913
14914 // Mark const if we don't care about errno and that is the only thing
14915 // preventing the function from being const. This allows IRgen to use LLVM
14916 // intrinsics for such functions.
14917 if (!getLangOpts().MathErrno && !FD->hasAttr<ConstAttr>() &&
14920
14921 // We make "fma" on some platforms const because we know it does not set
14922 // errno in those environments even though it could set errno based on the
14923 // C standard.
14924 const llvm::Triple &Trip = Context.getTargetInfo().getTriple();
14925 if ((Trip.isGNUEnvironment() || Trip.isAndroid() || Trip.isOSMSVCRT()) &&
14926 !FD->hasAttr<ConstAttr>()) {
14927 switch (BuiltinID) {
14928 case Builtin::BI__builtin_fma:
14929 case Builtin::BI__builtin_fmaf:
14930 case Builtin::BI__builtin_fmal:
14931 case Builtin::BIfma:
14932 case Builtin::BIfmaf:
14933 case Builtin::BIfmal:
14935 break;
14936 default:
14937 break;
14938 }
14939 }
14940
14941 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
14942 !FD->hasAttr<ReturnsTwiceAttr>())
14944 FD->getLocation()));
14945 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>())
14947 if (Context.BuiltinInfo.isPure(BuiltinID) && !FD->hasAttr<PureAttr>())
14949 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>())
14951 if (getLangOpts().CUDA && Context.BuiltinInfo.isTSBuiltin(BuiltinID) &&
14952 !FD->hasAttr<CUDADeviceAttr>() && !FD->hasAttr<CUDAHostAttr>()) {
14953 // Add the appropriate attribute, depending on the CUDA compilation mode
14954 // and which target the builtin belongs to. For example, during host
14955 // compilation, aux builtins are __device__, while the rest are __host__.
14956 if (getLangOpts().CUDAIsDevice !=
14959 else
14961 }
14962 }
14963
14965
14966 // If C++ exceptions are enabled but we are told extern "C" functions cannot
14967 // throw, add an implicit nothrow attribute to any extern "C" function we come
14968 // across.
14969 if (getLangOpts().CXXExceptions && getLangOpts().ExternCNoUnwind &&
14970 FD->isExternC() && !FD->hasAttr<NoThrowAttr>()) {
14971 const auto *FPT = FD->getType()->getAs<FunctionProtoType>();
14972 if (!FPT || FPT->getExceptionSpecType() == EST_None)
14974 }
14975
14976 IdentifierInfo *Name = FD->getIdentifier();
14977 if (!Name)
14978 return;
14979 if ((!getLangOpts().CPlusPlus &&
14981 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
14982 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
14984 // Okay: this could be a libc/libm/Objective-C function we know
14985 // about.
14986 } else
14987 return;
14988
14989 if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
14990 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
14991 // target-specific builtins, perhaps?
14992 if (!FD->hasAttr<FormatAttr>())
14994 &Context.Idents.get("printf"), 2,
14995 Name->isStr("vasprintf") ? 0 : 3,
14996 FD->getLocation()));
14997 }
14998
14999 if (Name->isStr("__CFStringMakeConstantString")) {
15000 // We already have a __builtin___CFStringMakeConstantString,
15001 // but builds that use -fno-constant-cfstrings don't go through that.
15002 if (!FD->hasAttr<FormatArgAttr>())
15004 FD->getLocation()));
15005 }
15006}
15007
15009 TypeSourceInfo *TInfo) {
15010 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
15011 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
15012
15013 if (!TInfo) {
15014 assert(D.isInvalidType() && "no declarator info for valid type");
15016 }
15017
15018 // Scope manipulation handled by caller.
15019 TypedefDecl *NewTD =
15021 D.getIdentifierLoc(), D.getIdentifier(), TInfo);
15022
15023 // Bail out immediately if we have an invalid declaration.
15024 if (D.isInvalidType()) {
15025 NewTD->setInvalidDecl();
15026 return NewTD;
15027 }
15028
15031 Diag(NewTD->getLocation(), diag::err_module_private_local)
15032 << 2 << NewTD
15036 else
15037 NewTD->setModulePrivate();
15038 }
15039
15040 // C++ [dcl.typedef]p8:
15041 // If the typedef declaration defines an unnamed class (or
15042 // enum), the first typedef-name declared by the declaration
15043 // to be that class type (or enum type) is used to denote the
15044 // class type (or enum type) for linkage purposes only.
15045 // We need to check whether the type was declared in the declaration.
15046 switch (D.getDeclSpec().getTypeSpecType()) {
15047 case TST_enum:
15048 case TST_struct:
15049 case TST_interface:
15050 case TST_union:
15051 case TST_class: {
15052 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
15053 setTagNameForLinkagePurposes(tagFromDeclSpec, NewTD);
15054 break;
15055 }
15056
15057 default:
15058 break;
15059 }
15060
15061 return NewTD;
15062}
15063
15064/// Check that this is a valid underlying type for an enum declaration.
15066 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
15067 QualType T = TI->getType();
15068
15069 if (T->isDependentType())
15070 return false;
15071
15072 // This doesn't use 'isIntegralType' despite the error message mentioning
15073 // integral type because isIntegralType would also allow enum types in C.
15074 if (const BuiltinType *BT = T->getAs<BuiltinType>())
15075 if (BT->isInteger())
15076 return false;
15077
15078 if (T->isExtIntType())
15079 return false;
15080
15081 return Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
15082}
15083
15084/// Check whether this is a valid redeclaration of a previous enumeration.
15085/// \return true if the redeclaration was invalid.
15087 QualType EnumUnderlyingTy, bool IsFixed,
15088 const EnumDecl *Prev) {
15089 if (IsScoped != Prev->isScoped()) {
15090 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
15091 << Prev->isScoped();
15092 Diag(Prev->getLocation(), diag::note_previous_declaration);
15093 return true;
15094 }
15095
15096 if (IsFixed && Prev->isFixed()) {
15097 if (!EnumUnderlyingTy->isDependentType() &&
15098 !Prev->getIntegerType()->isDependentType() &&
15099 !Context.hasSameUnqualifiedType(EnumUnderlyingTy,
15100 Prev->getIntegerType())) {
15101 // TODO: Highlight the underlying type of the redeclaration.
15102 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
15103 << EnumUnderlyingTy << Prev->getIntegerType();
15104 Diag(Prev->getLocation(), diag::note_previous_declaration)
15105 << Prev->getIntegerTypeRange();
15106 return true;
15107 }
15108 } else if (IsFixed != Prev->isFixed()) {
15109 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
15110 << Prev->isFixed();
15111 Diag(Prev->getLocation(), diag::note_previous_declaration);
15112 return true;
15113 }
15114
15115 return false;
15116}
15117
15118/// Get diagnostic %select index for tag kind for
15119/// redeclaration diagnostic message.
15120/// WARNING: Indexes apply to particular diagnostics only!
15121///
15122/// \returns diagnostic %select index.
15124 switch (Tag) {
15125 case TTK_Struct: return 0;
15126 case TTK_Interface: return 1;
15127 case TTK_Class: return 2;
15128 default: llvm_unreachable("Invalid tag kind for redecl diagnostic!");
15129 }
15130}
15131
15132/// Determine if tag kind is a class-key compatible with
15133/// class for redeclaration (class, struct, or __interface).
15134///
15135/// \returns true iff the tag kind is compatible.
15137{
15138 return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface;
15139}
15140
15142 TagTypeKind TTK) {
15143 if (isa<TypedefDecl>(PrevDecl))
15144 return NTK_Typedef;
15145 else if (isa<TypeAliasDecl>(PrevDecl))
15146 return NTK_TypeAlias;
15147 else if (isa<ClassTemplateDecl>(PrevDecl))
15148 return NTK_Template;
15149 else if (isa<TypeAliasTemplateDecl>(PrevDecl))
15150 return NTK_TypeAliasTemplate;
15151 else if (isa<TemplateTemplateParmDecl>(PrevDecl))
15153 switch (TTK) {
15154 case TTK_Struct:
15155 case TTK_Interface:
15156 case TTK_Class:
15157 return getLangOpts().CPlusPlus ? NTK_NonClass : NTK_NonStruct;
15158 case TTK_Union:
15159 return NTK_NonUnion;
15160 case TTK_Enum:
15161 return NTK_NonEnum;
15162 }
15163 llvm_unreachable("invalid TTK");
15164}
15165
15166/// Determine whether a tag with a given kind is acceptable
15167/// as a redeclaration of the given tag declaration.
15168///
15169/// \returns true if the new tag kind is acceptable, false otherwise.
15171 TagTypeKind NewTag, bool isDefinition,
15172 SourceLocation NewTagLoc,
15173 const IdentifierInfo *Name) {
15174 // C++ [dcl.type.elab]p3:
15175 // The class-key or enum keyword present in the
15176 // elaborated-type-specifier shall agree in kind with the
15177 // declaration to which the name in the elaborated-type-specifier
15178 // refers. This rule also applies to the form of
15179 // elaborated-type-specifier that declares a class-name or
15180 // friend class since it can be construed as referring to the
15181 // definition of the class. Thus, in any
15182 // elaborated-type-specifier, the enum keyword shall be used to
15183 // refer to an enumeration (7.2), the union class-key shall be
15184 // used to refer to a union (clause 9), and either the class or
15185 // struct class-key shall be used to refer to a class (clause 9)
15186 // declared using the class or struct class-key.
15187 TagTypeKind OldTag = Previous->getTagKind();
15188 if (OldTag != NewTag &&
15189 !(isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)))
15190 return false;
15191
15192 // Tags are compatible, but we might still want to warn on mismatched tags.
15193 // Non-class tags can't be mismatched at this point.
15194 if (!isClassCompatTagKind(NewTag))
15195 return true;
15196
15197 // Declarations for which -Wmismatched-tags is disabled are entirely ignored
15198 // by our warning analysis. We don't want to warn about mismatches with (eg)
15199 // declarations in system headers that are designed to be specialized, but if
15200 // a user asks us to warn, we should warn if their code contains mismatched
15201 // declarations.
15202 auto IsIgnoredLoc = [&](SourceLocation Loc) {
15203 return getDiagnostics().isIgnored(diag::warn_struct_class_tag_mismatch,
15204 Loc);
15205 };
15206 if (IsIgnoredLoc(NewTagLoc))
15207 return true;
15208
15209 auto IsIgnored = [&](const TagDecl *Tag) {
15210 return IsIgnoredLoc(Tag->getLocation());
15211 };
15212 while (IsIgnored(Previous)) {
15213 Previous = Previous->getPreviousDecl();
15214 if (!Previous)
15215 return true;
15216 OldTag = Previous->getTagKind();
15217 }
15218
15219 bool isTemplate = false;
15220 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
15221 isTemplate = Record->getDescribedClassTemplate();
15222
15224 if (OldTag != NewTag) {
15225 // In a template instantiation, do not offer fix-its for tag mismatches
15226 // since they usually mess up the template instead of fixing the problem.
15227 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
15228 << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
15229 << getRedeclDiagFromTagKind(OldTag);
15230 // FIXME: Note previous location?
15231 }
15232 return true;
15233 }
15234
15235 if (isDefinition) {
15236 // On definitions, check all previous tags and issue a fix-it for each
15237 // one that doesn't match the current tag.
15238 if (Previous->getDefinition()) {
15239 // Don't suggest fix-its for redefinitions.
15240 return true;
15241 }
15242
15243 bool previousMismatch = false;
15244 for (const TagDecl *I : Previous->redecls()) {
15245 if (I->getTagKind() != NewTag) {
15246 // Ignore previous declarations for which the warning was disabled.
15247 if (IsIgnored(I))
15248 continue;
15249
15250 if (!previousMismatch) {
15251 previousMismatch = true;
15252 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
15253 << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
15254 << getRedeclDiagFromTagKind(I->getTagKind());
15255 }
15256 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
15257 << getRedeclDiagFromTagKind(NewTag)
15258 << FixItHint::CreateReplacement(I->getInnerLocStart(),
15260 }
15261 }
15262 return true;
15263 }
15264
15265 // Identify the prevailing tag kind: this is the kind of the definition (if
15266 // there is a non-ignored definition), or otherwise the kind of the prior
15267 // (non-ignored) declaration.
15268 const TagDecl *PrevDef = Previous->getDefinition();
15269 if (PrevDef && IsIgnored(PrevDef))
15270 PrevDef = nullptr;
15271 const TagDecl *Redecl = PrevDef ? PrevDef : Previous;
15272 if (Redecl->getTagKind() != NewTag) {
15273 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
15274 << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
15275 << getRedeclDiagFromTagKind(OldTag);
15276 Diag(Redecl->getLocation(), diag::note_previous_use);
15277
15278 // If there is a previous definition, suggest a fix-it.
15279 if (PrevDef) {
15280 Diag(NewTagLoc, diag::note_struct_class_suggestion)
15284 }
15285 }
15286
15287 return true;
15288}
15289
15290/// Add a minimal nested name specifier fixit hint to allow lookup of a tag name
15291/// from an outer enclosing namespace or file scope inside a friend declaration.
15292/// This should provide the commented out code in the following snippet:
15293/// namespace N {
15294/// struct X;
15295/// namespace M {
15296/// struct Y { friend struct /*N::*/ X; };
15297/// }
15298/// }
15300 SourceLocation NameLoc) {
15301 // While the decl is in a namespace, do repeated lookup of that name and see
15302 // if we get the same namespace back. If we do not, continue until
15303 // translation unit scope, at which point we have a fully qualified NNS.
15306 for (; !DC->isTranslationUnit(); DC = DC->getParent()) {
15307 // This tag should be declared in a namespace, which can only be enclosed by
15308 // other namespaces. Bail if there's an anonymous namespace in the chain.
15309 NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC);
15310 if (!Namespace || Namespace->isAnonymousNamespace())
15311 return FixItHint();
15312 IdentifierInfo *II = Namespace->getIdentifier();
15313 Namespaces.push_back(II);
15314 NamedDecl *Lookup = SemaRef.LookupSingleName(
15315 S, II, NameLoc, Sema::LookupNestedNameSpecifierName);
15316 if (Lookup == Namespace)
15317 break;
15318 }
15319
15320 // Once we have all the namespaces, reverse them to go outermost first, and
15321 // build an NNS.
15322 SmallString<64> Insertion;
15323 llvm::raw_svector_ostream OS(Insertion);
15324 if (DC->isTranslationUnit())
15325 OS << "::";
15326 std::reverse(Namespaces.begin(), Namespaces.end());
15327 for (auto *II : Namespaces)
15328 OS << II->getName() << "::";
15329 return FixItHint::CreateInsertion(NameLoc, Insertion);
15330}
15331
15332/// Determine whether a tag originally declared in context \p OldDC can
15333/// be redeclared with an unqualified name in \p NewDC (assuming name lookup
15334/// found a declaration in \p OldDC as a previous decl, perhaps through a
15335/// using-declaration).
15337 DeclContext *NewDC) {
15338 OldDC = OldDC->getRedeclContext();
15339 NewDC = NewDC->getRedeclContext();
15340
15341 if (OldDC->Equals(NewDC))
15342 return true;
15343
15344 // In MSVC mode, we allow a redeclaration if the contexts are related (either
15345 // encloses the other).
15346 if (S.getLangOpts().MSVCCompat &&
15347 (OldDC->Encloses(NewDC) || NewDC->Encloses(OldDC)))
15348 return true;
15349
15350 return false;
15351}
15352
15353/// This is invoked when we see 'struct foo' or 'struct {'. In the
15354/// former case, Name will be non-null. In the later case, Name will be null.
15355/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
15356/// reference/declaration/definition of a tag.
15357///
15358/// \param IsTypeSpecifier \c true if this is a type-specifier (or
15359/// trailing-type-specifier) other than one in an alias-declaration.
15360///
15361/// \param SkipBody If non-null, will be set to indicate if the caller should
15362/// skip the definition of this tag and treat it as if it were a declaration.
15363Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
15364 SourceLocation KWLoc, CXXScopeSpec &SS,
15365 IdentifierInfo *Name, SourceLocation NameLoc,
15366 const ParsedAttributesView &Attrs, AccessSpecifier AS,
15367 SourceLocation ModulePrivateLoc,
15368 MultiTemplateParamsArg TemplateParameterLists,
15369 bool &OwnedDecl, bool &IsDependent,
15370 SourceLocation ScopedEnumKWLoc,
15371 bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
15372 bool IsTypeSpecifier, bool IsTemplateParamOrArg,
15373 SkipBodyInfo *SkipBody) {
15374 // If this is not a definition, it must have a name.
15375 IdentifierInfo *OrigName = Name;
15376 assert((Name != nullptr || TUK == TUK_Definition) &&
15377 "Nameless record must be a definition!");
15378 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
15379
15380 OwnedDecl = false;
15382 bool ScopedEnum = ScopedEnumKWLoc.isValid();
15383
15384 // FIXME: Check member specializations more carefully.
15385 bool isMemberSpecialization = false;
15386 bool Invalid = false;
15387
15388 // We only need to do this matching if we have template parameters
15389 // or a scope specifier, which also conveniently avoids this work
15390 // for non-C++ cases.
15391 if (TemplateParameterLists.size() > 0 ||
15392 (SS.isNotEmpty() && TUK != TUK_Reference)) {
15393 if (TemplateParameterList *TemplateParams =
15395 KWLoc, NameLoc, SS, nullptr, TemplateParameterLists,
15396 TUK == TUK_Friend, isMemberSpecialization, Invalid)) {
15397 if (Kind == TTK_Enum) {
15398 Diag(KWLoc, diag::err_enum_template);
15399 return nullptr;
15400 }
15401
15402 if (TemplateParams->size() > 0) {
15403 // This is a declaration or definition of a class template (which may
15404 // be a member of another template).
15405
15406 if (Invalid)
15407 return nullptr;
15408
15409 OwnedDecl = false;
15411 S, TagSpec, TUK, KWLoc, SS, Name, NameLoc, Attrs, TemplateParams,
15412 AS, ModulePrivateLoc,
15413 /*FriendLoc*/ SourceLocation(), TemplateParameterLists.size() - 1,
15414 TemplateParameterLists.data(), SkipBody);
15415 return Result.get();
15416 } else {
15417 // The "template<>" header is extraneous.
15418 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
15419 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
15420 isMemberSpecialization = true;
15421 }
15422 }
15423
15424 if (!TemplateParameterLists.empty() && isMemberSpecialization &&
15425 CheckTemplateDeclScope(S, TemplateParameterLists.back()))
15426 return nullptr;
15427 }
15428
15429 // Figure out the underlying type if this a enum declaration. We need to do
15430 // this early, because it's needed to detect if this is an incompatible
15431 // redeclaration.
15432 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
15433 bool IsFixed = !UnderlyingType.isUnset() || ScopedEnum;
15434
15435 if (Kind == TTK_Enum) {
15436 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum)) {
15437 // No underlying type explicitly specified, or we failed to parse the
15438 // type, default to int.
15439 EnumUnderlying = Context.IntTy.getTypePtr();
15440 } else if (UnderlyingType.get()) {
15441 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
15442 // integral type; any cv-qualification is ignored.
15443 TypeSourceInfo *TI = nullptr;
15444 GetTypeFromParser(UnderlyingType.get(), &TI);
15445 EnumUnderlying = TI;
15446
15448 // Recover by falling back to int.
15449 EnumUnderlying = Context.IntTy.getTypePtr();
15450
15453 EnumUnderlying = Context.IntTy.getTypePtr();
15454
15455 } else if (Context.getTargetInfo().getTriple().isWindowsMSVCEnvironment()) {
15456 // For MSVC ABI compatibility, unfixed enums must use an underlying type
15457 // of 'int'. However, if this is an unfixed forward declaration, don't set
15458 // the underlying type unless the user enables -fms-compatibility. This
15459 // makes unfixed forward declared enums incomplete and is more conforming.
15460 if (TUK == TUK_Definition || getLangOpts().MSVCCompat)
15461 EnumUnderlying = Context.IntTy.getTypePtr();
15462 }
15463 }
15464
15465 DeclContext *SearchDC = CurContext;
15466 DeclContext *DC = CurContext;
15467 bool isStdBadAlloc = false;
15468 bool isStdAlignValT = false;
15469
15471 if (TUK == TUK_Friend || TUK == TUK_Reference)
15472 Redecl = NotForRedeclaration;
15473
15474 /// Create a new tag decl in C/ObjC. Since the ODR-like semantics for ObjC/C
15475 /// implemented asks for structural equivalence checking, the returned decl
15476 /// here is passed back to the parser, allowing the tag body to be parsed.
15477 auto createTagFromNewDecl = [&]() -> TagDecl * {
15478 assert(!getLangOpts().CPlusPlus && "not meant for C++ usage");
15479 // If there is an identifier, use the location of the identifier as the
15480 // location of the decl, otherwise use the location of the struct/union
15481 // keyword.
15482 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
15483 TagDecl *New = nullptr;
15484
15485 if (Kind == TTK_Enum) {
15486 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, nullptr,
15487 ScopedEnum, ScopedEnumUsesClassTag, IsFixed);
15488 // If this is an undefined enum, bail.
15489 if (TUK != TUK_Definition && !Invalid)
15490 return nullptr;
15491 if (EnumUnderlying) {
15492 EnumDecl *ED = cast<EnumDecl>(New);
15493 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo *>())
15495 else
15496 ED->setIntegerType(QualType(EnumUnderlying.get<const Type *>(), 0));
15498 }
15499 } else { // struct/union
15500 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
15501 nullptr);
15502 }
15503
15504 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
15505 // Add alignment attributes if necessary; these attributes are checked
15506 // when the ASTContext lays out the structure.
15507 //
15508 // It is important for implementing the correct semantics that this
15509 // happen here (in ActOnTag). The #pragma pack stack is
15510 // maintained as a result of parser callbacks which can occur at
15511 // many points during the parsing of a struct declaration (because
15512 // the #pragma tokens are effectively skipped over during the
15513 // parsing of the struct).
15514 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip)) {
15517 }
15518 }
15520 return New;
15521 };
15522
15523 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
15524 if (Name && SS.isNotEmpty()) {
15525 // We have a nested-name tag ('struct foo::bar').
15526
15527 // Check for invalid 'foo::'.
15528 if (SS.isInvalid()) {
15529 Name = nullptr;
15530 goto CreateNewDecl;
15531 }
15532
15533 // If this is a friend or a reference to a class in a dependent
15534 // context, don't try to make a decl for it.
15535 if (TUK == TUK_Friend || TUK == TUK_Reference) {
15536 DC = computeDeclContext(SS, false);
15537 if (!DC) {
15538 IsDependent = true;
15539 return nullptr;
15540 }
15541 } else {
15542 DC = computeDeclContext(SS, true);
15543 if (!DC) {
15544 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
15545 << SS.getRange();
15546 return nullptr;
15547 }
15548 }
15549
15550 if (RequireCompleteDeclContext(SS, DC))
15551 return nullptr;
15552
15553 SearchDC = DC;
15554 // Look-up name inside 'foo::'.
15556
15557 if (Previous.isAmbiguous())
15558 return nullptr;
15559
15560 if (Previous.empty()) {
15561 // Name lookup did not find anything. However, if the
15562 // nested-name-specifier refers to the current instantiation,
15563 // and that current instantiation has any dependent base
15564 // classes, we might find something at instantiation time: treat
15565 // this as a dependent elaborated-type-specifier.
15566 // But this only makes any sense for reference-like lookups.
15567 if (Previous.wasNotFoundInCurrentInstantiation() &&
15568 (TUK == TUK_Reference || TUK == TUK_Friend)) {
15569 IsDependent = true;
15570 return nullptr;
15571 }
15572
15573 // A tag 'foo::bar' must already exist.
15574 Diag(NameLoc, diag::err_not_tag_in_scope)
15575 << Kind << Name << DC << SS.getRange();
15576 Name = nullptr;
15577 Invalid = true;
15578 goto CreateNewDecl;
15579 }
15580 } else if (Name) {
15581 // C++14 [class.mem]p14:
15582 // If T is the name of a class, then each of the following shall have a
15583 // name different from T:
15584 // -- every member of class T that is itself a type
15585 if (TUK != TUK_Reference && TUK != TUK_Friend &&
15586 DiagnoseClassNameShadow(SearchDC, DeclarationNameInfo(Name, NameLoc)))
15587 return nullptr;
15588
15589 // If this is a named struct, check to see if there was a previous forward
15590 // declaration or definition.
15591 // FIXME: We're looking into outer scopes here, even when we
15592 // shouldn't be. Doing so can result in ambiguities that we
15593 // shouldn't be diagnosing.
15594 LookupName(Previous, S);
15595
15596 // When declaring or defining a tag, ignore ambiguities introduced
15597 // by types using'ed into this scope.
15598 if (Previous.isAmbiguous() &&
15599 (TUK == TUK_Definition || TUK == TUK_Declaration)) {
15600 LookupResult::Filter F = Previous.makeFilter();
15601 while (F.hasNext()) {
15602 NamedDecl *ND = F.next();
15603 if (!ND->getDeclContext()->getRedeclContext()->Equals(
15604 SearchDC->getRedeclContext()))
15605 F.erase();
15606 }
15607 F.done();
15608 }
15609
15610 // C++11 [namespace.memdef]p3:
15611 // If the name in a friend declaration is neither qualified nor
15612 // a template-id and the declaration is a function or an
15613 // elaborated-type-specifier, the lookup to determine whether
15614 // the entity has been previously declared shall not consider
15615 // any scopes outside the innermost enclosing namespace.
15616 //
15617 // MSVC doesn't implement the above rule for types, so a friend tag
15618 // declaration may be a redeclaration of a type declared in an enclosing
15619 // scope. They do implement this rule for friend functions.
15620 //
15621 // Does it matter that this should be by scope instead of by
15622 // semantic context?
15623 if (!Previous.empty() && TUK == TUK_Friend) {
15624 DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext();
15625 LookupResult::Filter F = Previous.makeFilter();
15626 bool FriendSawTagOutsideEnclosingNamespace = false;
15627 while (F.hasNext()) {
15628 NamedDecl *ND = F.next();
15630 if (DC->isFileContext() &&
15631 !EnclosingNS->Encloses(ND->getDeclContext())) {
15632 if (getLangOpts().MSVCCompat)
15633 FriendSawTagOutsideEnclosingNamespace = true;
15634 else
15635 F.erase();
15636 }
15637 }
15638 F.done();
15639
15640 // Diagnose this MSVC extension in the easy case where lookup would have
15641 // unambiguously found something outside the enclosing namespace.
15642 if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
15643 NamedDecl *ND = Previous.getFoundDecl();
15644 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
15645 << createFriendTagNNSFixIt(*this, ND, S, NameLoc);
15646 }
15647 }
15648
15649 // Note: there used to be some attempt at recovery here.
15650 if (Previous.isAmbiguous())
15651 return nullptr;
15652
15653 if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) {
15654 // FIXME: This makes sure that we ignore the contexts associated
15655 // with C structs, unions, and enums when looking for a matching
15656 // tag declaration or definition. See the similar lookup tweak
15657 // in Sema::LookupName; is there a better way to deal with this?
15658 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
15659 SearchDC = SearchDC->getParent();
15660 }
15661 }
15662
15663 if (Previous.isSingleResult() &&
15664 Previous.getFoundDecl()->isTemplateParameter()) {
15665 // Maybe we will complain about the shadowed template parameter.
15666 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
15667 // Just pretend that we didn't see the previous declaration.
15668 Previous.clear();
15669 }
15670
15671 if (getLangOpts().CPlusPlus && Name && DC && StdNamespace &&
15672 DC->Equals(getStdNamespace())) {
15673 if (Name->isStr("bad_alloc")) {
15674 // This is a declaration of or a reference to "std::bad_alloc".
15675 isStdBadAlloc = true;
15676
15677 // If std::bad_alloc has been implicitly declared (but made invisible to
15678 // name lookup), fill in this implicit declaration as the previous
15679 // declaration, so that the declarations get chained appropriately.
15680 if (Previous.empty() && StdBadAlloc)
15681 Previous.addDecl(getStdBadAlloc());
15682 } else if (Name->isStr("align_val_t")) {
15683 isStdAlignValT = true;
15684 if (Previous.empty() && StdAlignValT)
15685 Previous.addDecl(getStdAlignValT());
15686 }
15687 }
15688
15689 // If we didn't find a previous declaration, and this is a reference
15690 // (or friend reference), move to the correct scope. In C++, we
15691 // also need to do a redeclaration lookup there, just in case
15692 // there's a shadow friend decl.
15693 if (Name && Previous.empty() &&
15694 (TUK == TUK_Reference || TUK == TUK_Friend || IsTemplateParamOrArg)) {
15695 if (Invalid) goto CreateNewDecl;
15696 assert(SS.isEmpty());
15697
15698 if (TUK == TUK_Reference || IsTemplateParamOrArg) {
15699 // C++ [basic.scope.pdecl]p5:
15700 // -- for an elaborated-type-specifier of the form
15701 //
15702 // class-key identifier
15703 //
15704 // if the elaborated-type-specifier is used in the
15705 // decl-specifier-seq or parameter-declaration-clause of a
15706 // function defined in namespace scope, the identifier is
15707 // declared as a class-name in the namespace that contains
15708 // the declaration; otherwise, except as a friend
15709 // declaration, the identifier is declared in the smallest
15710 // non-class, non-function-prototype scope that contains the
15711 // declaration.
15712 //
15713 // C99 6.7.2.3p8 has a similar (but not identical!) provision for
15714 // C structs and unions.
15715 //
15716 // It is an error in C++ to declare (rather than define) an enum
15717 // type, including via an elaborated type specifier. We'll
15718 // diagnose that later; for now, declare the enum in the same
15719 // scope as we would have picked for any other tag type.
15720 //
15721 // GNU C also supports this behavior as part of its incomplete
15722 // enum types extension, while GNU C++ does not.
15723 //
15724 // Find the context where we'll be declaring the tag.
15725 // FIXME: We would like to maintain the current DeclContext as the
15726 // lexical context,
15727 SearchDC = getTagInjectionContext(SearchDC);
15728
15729 // Find the scope where we'll be declaring the tag.
15731 } else {
15732 assert(TUK == TUK_Friend);
15733 // C++ [namespace.memdef]p3:
15734 // If a friend declaration in a non-local class first declares a
15735 // class or function, the friend class or function is a member of
15736 // the innermost enclosing namespace.
15737 SearchDC = SearchDC->getEnclosingNamespaceContext();
15738 }
15739
15740 // In C++, we need to do a redeclaration lookup to properly
15741 // diagnose some problems.
15742 // FIXME: redeclaration lookup is also used (with and without C++) to find a
15743 // hidden declaration so that we don't get ambiguity errors when using a
15744 // type declared by an elaborated-type-specifier. In C that is not correct
15745 // and we should instead merge compatible types found by lookup.
15746 if (getLangOpts().CPlusPlus) {
15747 // FIXME: This can perform qualified lookups into function contexts,
15748 // which are meaningless.
15749 Previous.setRedeclarationKind(forRedeclarationInCurContext());
15750 LookupQualifiedName(Previous, SearchDC);
15751 } else {
15752 Previous.setRedeclarationKind(forRedeclarationInCurContext());
15753 LookupName(Previous, S);
15754 }
15755 }
15756
15757 // If we have a known previous declaration to use, then use it.
15758 if (Previous.empty() && SkipBody && SkipBody->Previous)
15759 Previous.addDecl(SkipBody->Previous);
15760
15761 if (!Previous.empty()) {
15762 NamedDecl *PrevDecl = Previous.getFoundDecl();
15763 NamedDecl *DirectPrevDecl = Previous.getRepresentativeDecl();
15764
15765 // It's okay to have a tag decl in the same scope as a typedef
15766 // which hides a tag decl in the same scope. Finding this
15767 // insanity with a redeclaration lookup can only actually happen
15768 // in C++.
15769 //
15770 // This is also okay for elaborated-type-specifiers, which is
15771 // technically forbidden by the current standard but which is
15772 // okay according to the likely resolution of an open issue;
15773 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
15774 if (getLangOpts().CPlusPlus) {
15775 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
15776 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
15777 TagDecl *Tag = TT->getDecl();
15778 if (Tag->getDeclName() == Name &&
15779 Tag->getDeclContext()->getRedeclContext()
15780 ->Equals(TD->getDeclContext()->getRedeclContext())) {
15781 PrevDecl = Tag;
15782 Previous.clear();
15783 Previous.addDecl(Tag);
15784 Previous.resolveKind();
15785 }
15786 }
15787 }
15788 }
15789
15790 // If this is a redeclaration of a using shadow declaration, it must
15791 // declare a tag in the same context. In MSVC mode, we allow a
15792 // redefinition if either context is within the other.
15793 if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
15794 auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
15795 if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend &&
15796 isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) &&
15797 !(OldTag && isAcceptableTagRedeclContext(
15798 *this, OldTag->getDeclContext(), SearchDC))) {
15799 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
15800 Diag(Shadow->getTargetDecl()->getLocation(),
15801 diag::note_using_decl_target);
15802 Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl)
15803 << 0;
15804 // Recover by ignoring the old declaration.
15805 Previous.clear();
15806 goto CreateNewDecl;
15807 }
15808 }
15809
15810 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
15811 // If this is a use of a previous tag, or if the tag is already declared
15812 // in the same scope (so that the definition/declaration completes or
15813 // rementions the tag), reuse the decl.
15814 if (TUK == TUK_Reference || TUK == TUK_Friend ||
15815 isDeclInScope(DirectPrevDecl, SearchDC, S,
15816 SS.isNotEmpty() || isMemberSpecialization)) {
15817 // Make sure that this wasn't declared as an enum and now used as a
15818 // struct or something similar.
15819 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
15820 TUK == TUK_Definition, KWLoc,
15821 Name)) {
15822 bool SafeToContinue
15823 = (PrevTagDecl->getTagKind() != TTK_Enum &&
15824 Kind != TTK_Enum);
15825 if (SafeToContinue)
15826 Diag(KWLoc, diag::err_use_with_wrong_tag)
15827 << Name
15829 PrevTagDecl->getKindName());
15830 else
15831 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
15832 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
15833
15834 if (SafeToContinue)
15835 Kind = PrevTagDecl->getTagKind();
15836 else {
15837 // Recover by making this an anonymous redefinition.
15838 Name = nullptr;
15839 Previous.clear();
15840 Invalid = true;
15841 }
15842 }
15843
15844 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
15845 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
15846 if (TUK == TUK_Reference || TUK == TUK_Friend)
15847 return PrevTagDecl;
15848
15849 QualType EnumUnderlyingTy;
15850 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
15851 EnumUnderlyingTy = TI->getType().getUnqualifiedType();
15852 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
15853 EnumUnderlyingTy = QualType(T, 0);
15854
15855 // All conflicts with previous declarations are recovered by
15856 // returning the previous declaration, unless this is a definition,
15857 // in which case we want the caller to bail out.
15858 if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc,
15859 ScopedEnum, EnumUnderlyingTy,
15860 IsFixed, PrevEnum))
15861 return TUK == TUK_Declaration ? PrevTagDecl : nullptr;
15862 }
15863
15864 // C++11 [class.mem]p1:
15865 // A member shall not be declared twice in the member-specification,
15866 // except that a nested class or member class template can be declared
15867 // and then later defined.
15868 if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() &&
15869 S->isDeclScope(PrevDecl)) {
15870 Diag(NameLoc, diag::ext_member_redeclared);
15871 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
15872 }
15873
15874 if (!Invalid) {
15875 // If this is a use, just return the declaration we found, unless
15876 // we have attributes.
15877 if (TUK == TUK_Reference || TUK == TUK_Friend) {
15878 if (!Attrs.empty()) {
15879 // FIXME: Diagnose these attributes. For now, we create a new
15880 // declaration to hold them.
15881 } else if (TUK == TUK_Reference &&
15882 (PrevTagDecl->getFriendObjectKind() ==
15884 PrevDecl->getOwningModule() != getCurrentModule()) &&
15885 SS.isEmpty()) {
15886 // This declaration is a reference to an existing entity, but
15887 // has different visibility from that entity: it either makes
15888 // a friend visible or it makes a type visible in a new module.
15889 // In either case, create a new declaration. We only do this if
15890 // the declaration would have meant the same thing if no prior
15891 // declaration were found, that is, if it was found in the same
15892 // scope where we would have injected a declaration.
15893 if (!getTagInjectionContext(CurContext)->getRedeclContext()
15894 ->Equals(PrevDecl->getDeclContext()->getRedeclContext()))
15895 return PrevTagDecl;
15896 // This is in the injected scope, create a new declaration in
15897 // that scope.
15899 } else {
15900 return PrevTagDecl;
15901 }
15902 }
15903
15904 // Diagnose attempts to redefine a tag.
15905 if (TUK == TUK_Definition) {
15906 if (NamedDecl *Def = PrevTagDecl->getDefinition()) {
15907 // If we're defining a specialization and the previous definition
15908 // is from an implicit instantiation, don't emit an error
15909 // here; we'll catch this in the general case below.
15910 bool IsExplicitSpecializationAfterInstantiation = false;
15911 if (isMemberSpecialization) {
15912 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def))
15913 IsExplicitSpecializationAfterInstantiation =
15914 RD->getTemplateSpecializationKind() !=
15916 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def))
15917 IsExplicitSpecializationAfterInstantiation =
15918 ED->getTemplateSpecializationKind() !=
15920 }
15921
15922 // Note that clang allows ODR-like semantics for ObjC/C, i.e., do
15923 // not keep more that one definition around (merge them). However,
15924 // ensure the decl passes the structural compatibility check in
15925 // C11 6.2.7/1 (or 6.1.2.6/1 in C89).
15926 NamedDecl *Hidden = nullptr;
15927 if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
15928 // There is a definition of this tag, but it is not visible. We
15929 // explicitly make use of C++'s one definition rule here, and
15930 // assume that this definition is identical to the hidden one
15931 // we already have. Make the existing definition visible and
15932 // use it in place of this one.
15933 if (!getLangOpts().CPlusPlus) {
15934 // Postpone making the old definition visible until after we
15935 // complete parsing the new one and do the structural
15936 // comparison.
15937 SkipBody->CheckSameAsPrevious = true;
15938 SkipBody->New = createTagFromNewDecl();
15939 SkipBody->Previous = Def;
15940 return Def;
15941 } else {
15942 SkipBody->ShouldSkip = true;
15943 SkipBody->Previous = Def;
15945 // Carry on and handle it like a normal definition. We'll
15946 // skip starting the definitiion later.
15947 }
15948 } else if (!IsExplicitSpecializationAfterInstantiation) {
15949 // A redeclaration in function prototype scope in C isn't
15950 // visible elsewhere, so merely issue a warning.
15951 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())
15952 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
15953 else
15954 Diag(NameLoc, diag::err_redefinition) << Name;
15956 NameLoc.isValid() ? NameLoc : KWLoc);
15957 // If this is a redefinition, recover by making this
15958 // struct be anonymous, which will make any later
15959 // references get the previous definition.
15960 Name = nullptr;
15961 Previous.clear();
15962 Invalid = true;
15963 }
15964 } else {
15965 // If the type is currently being defined, complain
15966 // about a nested redefinition.
15967 auto *TD = Context.getTagDeclType(PrevTagDecl)->getAsTagDecl();
15968 if (TD->isBeingDefined()) {
15969 Diag(NameLoc, diag::err_nested_redefinition) << Name;
15970 Diag(PrevTagDecl->getLocation(),
15971 diag::note_previous_definition);
15972 Name = nullptr;
15973 Previous.clear();
15974 Invalid = true;
15975 }
15976 }
15977
15978 // Okay, this is definition of a previously declared or referenced
15979 // tag. We're going to create a new Decl for it.
15980 }
15981
15982 // Okay, we're going to make a redeclaration. If this is some kind
15983 // of reference, make sure we build the redeclaration in the same DC
15984 // as the original, and ignore the current access specifier.
15985 if (TUK == TUK_Friend || TUK == TUK_Reference) {
15986 SearchDC = PrevTagDecl->getDeclContext();
15987 AS = AS_none;
15988 }
15989 }
15990 // If we get here we have (another) forward declaration or we
15991 // have a definition. Just create a new decl.
15992
15993 } else {
15994 // If we get here, this is a definition of a new tag type in a nested
15995 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
15996 // new decl/type. We set PrevDecl to NULL so that the entities
15997 // have distinct types.
15998 Previous.clear();
15999 }
16000 // If we get here, we're going to create a new Decl. If PrevDecl
16001 // is non-NULL, it's a definition of the tag declared by
16002 // PrevDecl. If it's NULL, we have a new definition.
16003
16004 // Otherwise, PrevDecl is not a tag, but was found with tag
16005 // lookup. This is only actually possible in C++, where a few
16006 // things like templates still live in the tag namespace.
16007 } else {
16008 // Use a better diagnostic if an elaborated-type-specifier
16009 // found the wrong kind of type on the first
16010 // (non-redeclaration) lookup.
16011 if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
16012 !Previous.isForRedeclaration()) {
16013 NonTagKind NTK = getNonTagTypeDeclKind(PrevDecl, Kind);
16014 Diag(NameLoc, diag::err_tag_reference_non_tag) << PrevDecl << NTK
16015 << Kind;
16016 Diag(PrevDecl->getLocation(), diag::note_declared_at);
16017 Invalid = true;
16018
16019 // Otherwise, only diagnose if the declaration is in scope.
16020 } else if (!isDeclInScope(DirectPrevDecl, SearchDC, S,
16021 SS.isNotEmpty() || isMemberSpecialization)) {
16022 // do nothing
16023
16024 // Diagnose implicit declarations introduced by elaborated types.
16025 } else if (TUK == TUK_Reference || TUK == TUK_Friend) {
16026 NonTagKind NTK = getNonTagTypeDeclKind(PrevDecl, Kind);
16027 Diag(NameLoc, diag::err_tag_reference_conflict) << NTK;
16028 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
16029 Invalid = true;
16030
16031 // Otherwise it's a declaration. Call out a particularly common
16032 // case here.
16033 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
16034 unsigned Kind = 0;
16035 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
16036 Diag(NameLoc, diag::err_tag_definition_of_typedef)
16037 << Name << Kind << TND->getUnderlyingType();
16038 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
16039 Invalid = true;
16040
16041 // Otherwise, diagnose.
16042 } else {
16043 // The tag name clashes with something else in the target scope,
16044 // issue an error and recover by making this tag be anonymous.
16045 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
16046 notePreviousDefinition(PrevDecl, NameLoc);
16047 Name = nullptr;
16048 Invalid = true;
16049 }
16050
16051 // The existing declaration isn't relevant to us; we're in a
16052 // new scope, so clear out the previous declaration.
16053 Previous.clear();
16054 }
16055 }
16056
16057CreateNewDecl:
16058
16059 TagDecl *PrevDecl = nullptr;
16060 if (Previous.isSingleResult())
16061 PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
16062
16063 // If there is an identifier, use the location of the identifier as the
16064 // location of the decl, otherwise use the location of the struct/union
16065 // keyword.
16066 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
16067
16068 // Otherwise, create a new declaration. If there is a previous
16069 // declaration of the same entity, the two will be linked via
16070 // PrevDecl.
16071 TagDecl *New;
16072
16073 if (Kind == TTK_Enum) {
16074 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
16075 // enum X { A, B, C } D; D should chain to X.
16076 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
16077 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
16078 ScopedEnumUsesClassTag, IsFixed);
16079
16080 if (isStdAlignValT && (!StdAlignValT || getStdAlignValT()->isImplicit()))
16082
16083 // If this is an undefined enum, warn.
16084 if (TUK != TUK_Definition && !Invalid) {
16085 TagDecl *Def;
16086 if (IsFixed && cast<EnumDecl>(New)->isFixed()) {
16087 // C++0x: 7.2p2: opaque-enum-declaration.
16088 // Conflicts are diagnosed above. Do nothing.
16089 }
16090 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
16091 Diag(Loc, diag::ext_forward_ref_enum_def)
16092 << New;
16093 Diag(Def->getLocation(), diag::note_previous_definition);
16094 } else {
16095 unsigned DiagID = diag::ext_forward_ref_enum;
16096 if (getLangOpts().MSVCCompat)
16097 DiagID = diag::ext_ms_forward_ref_enum;
16098 else if (getLangOpts().CPlusPlus)
16099 DiagID = diag::err_forward_ref_enum;
16100 Diag(Loc, DiagID);
16101 }
16102 }
16103
16104 if (EnumUnderlying) {
16105 EnumDecl *ED = cast<EnumDecl>(New);
16106 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
16108 else
16109 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
16111 assert(ED->isComplete() && "enum with type should be complete");
16112 }
16113 } else {
16114 // struct/union/class
16115
16116 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
16117 // struct X { int A; } D; D should chain to X.
16118 if (getLangOpts().CPlusPlus) {
16119 // FIXME: Look for a way to use RecordDecl for simple structs.
16120 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
16121 cast_or_null<CXXRecordDecl>(PrevDecl));
16122
16123 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit()))
16125 } else
16126 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
16127 cast_or_null<RecordDecl>(PrevDecl));
16128 }
16129
16130 // C++11 [dcl.type]p3:
16131 // A type-specifier-seq shall not define a class or enumeration [...].
16132 if (getLangOpts().CPlusPlus && (IsTypeSpecifier || IsTemplateParamOrArg) &&
16133 TUK == TUK_Definition) {
16134 Diag(New->getLocation(), diag::err_type_defined_in_type_specifier)
16135 << Context.getTagDeclType(New);
16136 Invalid = true;
16137 }
16138
16139 if (!Invalid && getLangOpts().CPlusPlus && TUK == TUK_Definition &&
16140 DC->getDeclKind() == Decl::Enum) {
16141 Diag(New->getLocation(), diag::err_type_defined_in_enum)
16142 << Context.getTagDeclType(New);
16143 Invalid = true;
16144 }
16145
16146 // Maybe add qualifier info.
16147 if (SS.isNotEmpty()) {
16148 if (SS.isSet()) {
16149 // If this is either a declaration or a definition, check the
16150 // nested-name-specifier against the current context.
16151 if ((TUK == TUK_Definition || TUK == TUK_Declaration) &&
16152 diagnoseQualifiedDeclaration(SS, DC, OrigName, Loc,
16153 isMemberSpecialization))
16154 Invalid = true;
16155
16157 if (TemplateParameterLists.size() > 0) {
16158 New->setTemplateParameterListsInfo(Context, TemplateParameterLists);
16159 }
16160 }
16161 else
16162 Invalid = true;
16163 }
16164
16165 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
16166 // Add alignment attributes if necessary; these attributes are checked when
16167 // the ASTContext lays out the structure.
16168 //
16169 // It is important for implementing the correct semantics that this
16170 // happen here (in ActOnTag). The #pragma pack stack is
16171 // maintained as a result of parser callbacks which can occur at
16172 // many points during the parsing of a struct declaration (because
16173 // the #pragma tokens are effectively skipped over during the
16174 // parsing of the struct).
16175 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip)) {
16178 }
16179 }
16180
16181 if (ModulePrivateLoc.isValid()) {
16182 if (isMemberSpecialization)
16183 Diag(New->getLocation(), diag::err_module_private_specialization)
16184 << 2
16185 << FixItHint::CreateRemoval(ModulePrivateLoc);
16186 // __module_private__ does not apply to local classes. However, we only
16187 // diagnose this as an error when the declaration specifiers are
16188 // freestanding. Here, we just ignore the __module_private__.
16189 else if (!SearchDC->isFunctionOrMethod())
16190 New->setModulePrivate();
16191 }
16192
16193 // If this is a specialization of a member class (of a class template),
16194 // check the specialization.
16195 if (isMemberSpecialization && CheckMemberSpecialization(New, Previous))
16196 Invalid = true;
16197
16198 // If we're declaring or defining a tag in function prototype scope in C,
16199 // note that this type can only be used within the function and add it to
16200 // the list of decls to inject into the function definition scope.
16201 if ((Name || Kind == TTK_Enum) &&
16202 getNonFieldDeclScope(S)->isFunctionPrototypeScope()) {
16203 if (getLangOpts().CPlusPlus) {
16204 // C++ [dcl.fct]p6:
16205 // Types shall not be defined in return or parameter types.
16206 if (TUK == TUK_Definition && !IsTypeSpecifier) {
16207 Diag(Loc, diag::err_type_defined_in_param_type)
16208 << Name;
16209 Invalid = true;
16210 }
16211 } else if (!PrevDecl) {
16212 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
16213 }
16214 }
16215
16216 if (Invalid)
16217 New->setInvalidDecl();
16218
16219 // Set the lexical context. If the tag has a C++ scope specifier, the
16220 // lexical context will be different from the semantic context.
16222
16223 // Mark this as a friend decl if applicable.
16224 // In Microsoft mode, a friend declaration also acts as a forward
16225 // declaration so we always pass true to setObjectOfFriendDecl to make
16226 // the tag name visible.
16227 if (TUK == TUK_Friend)
16228 New->setObjectOfFriendDecl(getLangOpts().MSVCCompat);
16229
16230 // Set the access specifier.
16231 if (!Invalid && SearchDC->isRecord())
16232 SetMemberAccessSpecifier(New, PrevDecl, AS);
16233
16234 if (PrevDecl)
16235 CheckRedeclarationModuleOwnership(New, PrevDecl);
16236
16237 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip))
16238 New->startDefinition();
16239
16240 ProcessDeclAttributeList(S, New, Attrs);
16241 AddPragmaAttributes(S, New);
16242
16243 // If this has an identifier, add it to the scope stack.
16244 if (TUK == TUK_Friend) {
16245 // We might be replacing an existing declaration in the lookup tables;
16246 // if so, borrow its access specifier.
16247 if (PrevDecl)
16248 New->setAccess(PrevDecl->getAccess());
16249
16251 DC->makeDeclVisibleInContext(New);
16252 if (Name) // can be null along some error paths
16253 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
16254 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
16255 } else if (Name) {
16256 S = getNonFieldDeclScope(S);
16257 PushOnScopeChains(New, S, true);
16258 } else {
16259 CurContext->addDecl(New);
16260 }
16261
16262 // If this is the C FILE type, notify the AST context.
16263 if (IdentifierInfo *II = New->getIdentifier())
16264 if (!New->isInvalidDecl() &&
16266 II->isStr("FILE"))
16267 Context.setFILEDecl(New);
16268
16269 if (PrevDecl)
16270 mergeDeclAttributes(New, PrevDecl);
16271
16272 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(New))
16274
16275 // If there's a #pragma GCC visibility in scope, set the visibility of this
16276 // record.
16278
16279 if (isMemberSpecialization && !New->isInvalidDecl())
16281
16282 OwnedDecl = true;
16283 // In C++, don't return an invalid declaration. We can't recover well from
16284 // the cases where we make the type anonymous.
16285 if (Invalid && getLangOpts().CPlusPlus) {
16286 if (New->isBeingDefined())
16287 if (auto RD = dyn_cast<RecordDecl>(New))
16288 RD->completeDefinition();
16289 return nullptr;
16290 } else if (SkipBody && SkipBody->ShouldSkip) {
16291 return SkipBody->Previous;
16292 } else {
16293 return New;
16294 }
16295}
16296
16299 TagDecl *Tag = cast<TagDecl>(TagD);
16300
16301 // Enter the tag context.
16302 PushDeclContext(S, Tag);
16303
16305
16306 // If there's a #pragma GCC visibility in scope, set the visibility of this
16307 // record.
16309}
16310
16312 SkipBodyInfo &SkipBody) {
16313 if (!hasStructuralCompatLayout(Prev, SkipBody.New))
16314 return false;
16315
16316 // Make the previous decl visible.
16318 return true;
16319}
16320
16322 assert(isa<ObjCContainerDecl>(IDecl) &&
16323 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl");
16324 DeclContext *OCD = cast<DeclContext>(IDecl);
16325 assert(OCD->getLexicalParent() == CurContext &&
16326 "The next DeclContext should be lexically contained in the current one.");
16327 CurContext = OCD;
16328 return IDecl;
16329}
16330
16332 SourceLocation FinalLoc,
16333 bool IsFinalSpelledSealed,
16334 SourceLocation LBraceLoc) {
16336 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
16337
16338 FieldCollector->StartClass();
16339
16340 if (!Record->getIdentifier())
16341 return;
16342
16343 if (FinalLoc.isValid())
16344 Record->addAttr(FinalAttr::Create(
16346 static_cast<FinalAttr::Spelling>(IsFinalSpelledSealed)));
16347
16348 // C++ [class]p2:
16349 // [...] The class-name is also inserted into the scope of the
16350 // class itself; this is known as the injected-class-name. For
16351 // purposes of access checking, the injected-class-name is treated
16352 // as if it were a public member name.
16353 CXXRecordDecl *InjectedClassName = CXXRecordDecl::Create(
16354 Context, Record->getTagKind(), CurContext, Record->getBeginLoc(),
16355 Record->getLocation(), Record->getIdentifier(),
16356 /*PrevDecl=*/nullptr,
16357 /*DelayTypeCreation=*/true);
16358 Context.getTypeDeclType(InjectedClassName, Record);
16359 InjectedClassName->setImplicit();
16360 InjectedClassName->setAccess(AS_public);
16361 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
16362 InjectedClassName->setDescribedClassTemplate(Template);
16363 PushOnScopeChains(InjectedClassName, S);
16364 assert(InjectedClassName->isInjectedClassName() &&
16365 "Broken injected-class-name");
16366}
16367
16369 SourceRange BraceRange) {
16371 TagDecl *Tag = cast<TagDecl>(TagD);
16372 Tag->setBraceRange(BraceRange);
16373
16374 // Make sure we "complete" the definition even it is invalid.
16375 if (Tag->isBeingDefined()) {
16376 assert(Tag->isInvalidDecl() && "We should already have completed it");
16377 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
16378 RD->completeDefinition();
16379 }
16380
16381 if (isa<CXXRecordDecl>(Tag)) {
16382 FieldCollector->FinishClass();
16383 }
16384
16385 // Exit this scope of this tag's definition.
16387
16388 if (getCurLexicalContext()->isObjCContainer() &&
16389 Tag->getDeclContext()->isFileContext())
16390 Tag->setTopLevelDeclInObjCContainer();
16391
16392 // Notify the consumer that we've defined a tag.
16393 if (!Tag->isInvalidDecl())
16395}
16396
16398 // Exit this scope of this interface definition.
16400}
16401
16403 assert(DC == CurContext && "Mismatch of container contexts");
16406}
16407
16412
16415 TagDecl *Tag = cast<TagDecl>(TagD);
16416 Tag->setInvalidDecl();
16417
16418 // Make sure we "complete" the definition even it is invalid.
16419 if (Tag->isBeingDefined()) {
16420 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
16421 RD->completeDefinition();
16422 }
16423
16424 // We're undoing ActOnTagStartDefinition here, not
16425 // ActOnStartCXXMemberDeclarations, so we don't have to mess with
16426 // the FieldCollector.
16427
16429}
16430
16431// Note that FieldName may be null for anonymous bitfields.
16433 IdentifierInfo *FieldName,
16434 QualType FieldTy, bool IsMsStruct,
16435 Expr *BitWidth, bool *ZeroWidth) {
16436 assert(BitWidth);
16437 if (BitWidth->containsErrors())
16438 return ExprError();
16439
16440 // Default to true; that shouldn't confuse checks for emptiness
16441 if (ZeroWidth)
16442 *ZeroWidth = true;
16443
16444 // C99 6.7.2.1p4 - verify the field type.
16445 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
16446 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
16447 // Handle incomplete and sizeless types with a specific error.
16448 if (RequireCompleteSizedType(FieldLoc, FieldTy,
16449 diag::err_field_incomplete_or_sizeless))
16450 return ExprError();
16451 if (FieldName)
16452 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
16453 << FieldName << FieldTy << BitWidth->getSourceRange();
16454 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
16455 << FieldTy << BitWidth->getSourceRange();
16456 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
16458 return ExprError();
16459
16460 // If the bit-width is type- or value-dependent, don't try to check
16461 // it now.
16462 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
16463 return BitWidth;
16464
16465 llvm::APSInt Value;
16467 if (ICE.isInvalid())
16468 return ICE;
16469 BitWidth = ICE.get();
16470
16471 if (Value != 0 && ZeroWidth)
16472 *ZeroWidth = false;
16473
16474 // Zero-width bitfield is ok for anonymous field.
16475 if (Value == 0 && FieldName)
16476 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
16477
16478 if (Value.isSigned() && Value.isNegative()) {
16479 if (FieldName)
16480 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
16481 << FieldName << Value.toString(10);
16482 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
16483 << Value.toString(10);
16484 }
16485
16486 // The size of the bit-field must not exceed our maximum permitted object
16487 // size.
16488 if (Value.getActiveBits() > ConstantArrayType::getMaxSizeBits(Context)) {
16489 return Diag(FieldLoc, diag::err_bitfield_too_wide)
16490 << !FieldName << FieldName << Value.toString(10);
16491 }
16492
16493 if (!FieldTy->isDependentType()) {
16494 uint64_t TypeStorageSize = Context.getTypeSize(FieldTy);
16495 uint64_t TypeWidth = Context.getIntWidth(FieldTy);
16496 bool BitfieldIsOverwide = Value.ugt(TypeWidth);
16497
16498 // Over-wide bitfields are an error in C or when using the MSVC bitfield
16499 // ABI.
16500 bool CStdConstraintViolation =
16501 BitfieldIsOverwide && !getLangOpts().CPlusPlus;
16502 bool MSBitfieldViolation =
16503 Value.ugt(TypeStorageSize) &&
16504 (IsMsStruct || Context.getTargetInfo().getCXXABI().isMicrosoft());
16505 if (CStdConstraintViolation || MSBitfieldViolation) {
16506 unsigned DiagWidth =
16507 CStdConstraintViolation ? TypeWidth : TypeStorageSize;
16508 if (FieldName)
16509 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
16510 << FieldName << Value.toString(10)
16511 << !CStdConstraintViolation << DiagWidth;
16512
16513 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_width)
16514 << Value.toString(10) << !CStdConstraintViolation
16515 << DiagWidth;
16516 }
16517
16518 // Warn on types where the user might conceivably expect to get all
16519 // specified bits as value bits: that's all integral types other than
16520 // 'bool'.
16521 if (BitfieldIsOverwide && !FieldTy->isBooleanType() && FieldName) {
16522 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
16523 << FieldName << Value.toString(10)
16524 << (unsigned)TypeWidth;
16525 }
16526 }
16527
16528 return BitWidth;
16529}
16530
16531/// ActOnField - Each field of a C struct/union is passed into this in order
16532/// to create a FieldDecl object for it.
16534 Declarator &D, Expr *BitfieldWidth) {
16535 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
16536 DeclStart, D, static_cast<Expr*>(BitfieldWidth),
16537 /*InitStyle=*/ICIS_NoInit, AS_public);
16538 return Res;
16539}
16540
16541/// HandleField - Analyze a field of a C struct or a C++ data member.
16542///
16544 SourceLocation DeclStart,
16545 Declarator &D, Expr *BitWidth,
16546 InClassInitStyle InitStyle,
16547 AccessSpecifier AS) {
16548 if (D.isDecompositionDeclarator()) {
16550 Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context)
16551 << Decomp.getSourceRange();
16552 return nullptr;
16553 }
16554
16555 IdentifierInfo *II = D.getIdentifier();
16556 SourceLocation Loc = DeclStart;
16557 if (II) Loc = D.getIdentifierLoc();
16558
16559 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
16560 QualType T = TInfo->getType();
16561 if (getLangOpts().CPlusPlus) {
16563
16566 D.setInvalidType();
16567 T = Context.IntTy;
16568 TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
16569 }
16570 }
16571
16573
16575 Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
16576 << getLangOpts().CPlusPlus17;
16579 diag::err_invalid_thread)
16581
16582 // Check to see if this name was declared as a member previously
16583 NamedDecl *PrevDecl = nullptr;
16584 LookupResult Previous(*this, II, Loc, LookupMemberName,
16586 LookupName(Previous, S);
16587 switch (Previous.getResultKind()) {
16590 PrevDecl = Previous.getAsSingle<NamedDecl>();
16591 break;
16592
16594 PrevDecl = Previous.getRepresentativeDecl();
16595 break;
16596
16600 break;
16601 }
16602 Previous.suppressDiagnostics();
16603
16604 if (PrevDecl && PrevDecl->isTemplateParameter()) {
16605 // Maybe we will complain about the shadowed template parameter.
16607 // Just pretend that we didn't see the previous declaration.
16608 PrevDecl = nullptr;
16609 }
16610
16611 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
16612 PrevDecl = nullptr;
16613
16614 bool Mutable
16615 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
16616 SourceLocation TSSL = D.getBeginLoc();
16617 FieldDecl *NewFD
16618 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
16619 TSSL, AS, PrevDecl, &D);
16620
16621 if (NewFD->isInvalidDecl())
16622 Record->setInvalidDecl();
16623
16625 NewFD->setModulePrivate();
16626
16627 if (NewFD->isInvalidDecl() && PrevDecl) {
16628 // Don't introduce NewFD into scope; there's already something
16629 // with the same name in the same scope.
16630 } else if (II) {
16631 PushOnScopeChains(NewFD, S);
16632 } else
16633 Record->addDecl(NewFD);
16634
16635 return NewFD;
16636}
16637
16638/// Build a new FieldDecl and check its well-formedness.
16639///
16640/// This routine builds a new FieldDecl given the fields name, type,
16641/// record, etc. \p PrevDecl should refer to any previous declaration
16642/// with the same name and in the same scope as the field to be
16643/// created.
16644///
16645/// \returns a new FieldDecl.
16646///
16647/// \todo The Declarator argument is a hack. It will be removed once
16649 TypeSourceInfo *TInfo,
16650 RecordDecl *Record, SourceLocation Loc,
16651 bool Mutable, Expr *BitWidth,
16652 InClassInitStyle InitStyle,
16653 SourceLocation TSSL,
16654 AccessSpecifier AS, NamedDecl *PrevDecl,
16655 Declarator *D) {
16656 IdentifierInfo *II = Name.getAsIdentifierInfo();
16657 bool InvalidDecl = false;
16658 if (D) InvalidDecl = D->isInvalidType();
16659
16660 // If we receive a broken type, recover by assuming 'int' and
16661 // marking this declaration as invalid.
16662 if (T.isNull() || T->containsErrors()) {
16663 InvalidDecl = true;
16664 T = Context.IntTy;
16665 }
16666
16668 if (!EltTy->isDependentType() && !EltTy->containsErrors()) {
16669 if (RequireCompleteSizedType(Loc, EltTy,
16670 diag::err_field_incomplete_or_sizeless)) {
16671 // Fields of incomplete type force their record to be invalid.
16672 Record->setInvalidDecl();
16673 InvalidDecl = true;
16674 } else {
16675 NamedDecl *Def;
16676 EltTy->isIncompleteType(&Def);
16677 if (Def && Def->isInvalidDecl()) {
16678 Record->setInvalidDecl();
16679 InvalidDecl = true;
16680 }
16681 }
16682 }
16683
16684 // TR 18037 does not allow fields to be declared with address space
16685 if (T.hasAddressSpace() || T->isDependentAddressSpaceType() ||
16686 T->getBaseElementTypeUnsafe()->isDependentAddressSpaceType()) {
16687 Diag(Loc, diag::err_field_with_address_space);
16688 Record->setInvalidDecl();
16689 InvalidDecl = true;
16690 }
16691
16692 if (LangOpts.OpenCL) {
16693 // OpenCL v1.2 s6.9b,r & OpenCL v2.0 s6.12.5 - The following types cannot be
16694 // used as structure or union field: image, sampler, event or block types.
16695 if (T->isEventT() || T->isImageType() || T->isSamplerT() ||
16696 T->isBlockPointerType()) {
16697 Diag(Loc, diag::err_opencl_type_struct_or_union_field) << T;
16698 Record->setInvalidDecl();
16699 InvalidDecl = true;
16700 }
16701 // OpenCL v1.2 s6.9.c: bitfields are not supported.
16702 if (BitWidth) {
16703 Diag(Loc, diag::err_opencl_bitfields);
16704 InvalidDecl = true;
16705 }
16706 }
16707
16708 // Anonymous bit-fields cannot be cv-qualified (CWG 2229).
16709 if (!InvalidDecl && getLangOpts().CPlusPlus && !II && BitWidth &&
16710 T.hasQualifiers()) {
16711 InvalidDecl = true;
16712 Diag(Loc, diag::err_anon_bitfield_qualifiers);
16713 }
16714
16715 // C99 6.7.2.1p8: A member of a structure or union may have any type other
16716 // than a variably modified type.
16717 if (!InvalidDecl && T->isVariablyModifiedType()) {
16719 *this, TInfo, T, Loc, diag::err_typecheck_field_variable_size))
16720 InvalidDecl = true;
16721 }
16722
16723 // Fields can not have abstract class types
16724 if (!InvalidDecl && RequireNonAbstractType(Loc, T,
16725 diag::err_abstract_type_in_decl,
16727 InvalidDecl = true;
16728
16729 bool ZeroWidth = false;
16730 if (InvalidDecl)
16731 BitWidth = nullptr;
16732 // If this is declared as a bit-field, check the bit-field.
16733 if (BitWidth) {
16734 BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth,
16735 &ZeroWidth).get();
16736 if (!BitWidth) {
16737 InvalidDecl = true;
16738 BitWidth = nullptr;
16739 ZeroWidth = false;
16740 }
16741 }
16742
16743 // Check that 'mutable' is consistent with the type of the declaration.
16744 if (!InvalidDecl && Mutable) {
16745 unsigned DiagID = 0;
16746 if (T->isReferenceType())
16747 DiagID = getLangOpts().MSVCCompat ? diag::ext_mutable_reference
16748 : diag::err_mutable_reference;
16749 else if (T.isConstQualified())
16750 DiagID = diag::err_mutable_const;
16751
16752 if (DiagID) {
16753 SourceLocation ErrLoc = Loc;
16754 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
16755 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
16756 Diag(ErrLoc, DiagID);
16757 if (DiagID != diag::ext_mutable_reference) {
16758 Mutable = false;
16759 InvalidDecl = true;
16760 }
16761 }
16762 }
16763
16764 // C++11 [class.union]p8 (DR1460):
16765 // At most one variant member of a union may have a
16766 // brace-or-equal-initializer.
16767 if (InitStyle != ICIS_NoInit)
16768 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
16769
16770 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
16771 BitWidth, Mutable, InitStyle);
16772 if (InvalidDecl)
16773 NewFD->setInvalidDecl();
16774
16775 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
16776 Diag(Loc, diag::err_duplicate_member) << II;
16777 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
16778 NewFD->setInvalidDecl();
16779 }
16780
16781 if (!InvalidDecl && getLangOpts().CPlusPlus) {
16782 if (Record->isUnion()) {
16783 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
16784 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
16785 if (RDecl->getDefinition()) {
16786 // C++ [class.union]p1: An object of a class with a non-trivial
16787 // constructor, a non-trivial copy constructor, a non-trivial
16788 // destructor, or a non-trivial copy assignment operator
16789 // cannot be a member of a union, nor can an array of such
16790 // objects.
16791 if (CheckNontrivialField(NewFD))
16792 NewFD->setInvalidDecl();
16793 }
16794 }
16795
16796 // C++ [class.union]p1: If a union contains a member of reference type,
16797 // the program is ill-formed, except when compiling with MSVC extensions
16798 // enabled.
16799 if (EltTy->isReferenceType()) {
16800 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
16801 diag::ext_union_member_of_reference_type :
16802 diag::err_union_member_of_reference_type)
16803 << NewFD->getDeclName() << EltTy;
16804 if (!getLangOpts().MicrosoftExt)
16805 NewFD->setInvalidDecl();
16806 }
16807 }
16808 }
16809
16810 // FIXME: We need to pass in the attributes given an AST
16811 // representation, not a parser representation.
16812 if (D) {
16813 // FIXME: The current scope is almost... but not entirely... correct here.
16814 ProcessDeclAttributes(getCurScope(), NewFD, *D);
16815
16816 if (NewFD->hasAttrs())
16818 }
16819
16820 // In auto-retain/release, infer strong retension for fields of
16821 // retainable type.
16822 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
16823 NewFD->setInvalidDecl();
16824
16825 if (T.isObjCGCWeak())
16826 Diag(Loc, diag::warn_attribute_weak_on_field);
16827
16828 // PPC MMA non-pointer types are not allowed as field types.
16829 if (Context.getTargetInfo().getTriple().isPPC64() &&
16830 CheckPPCMMAType(T, NewFD->getLocation()))
16831 NewFD->setInvalidDecl();
16832
16833 NewFD->setAccess(AS);
16834 return NewFD;
16835}
16836
16838 assert(FD);
16839 assert(getLangOpts().CPlusPlus && "valid check only for C++");
16840
16841 if (FD->isInvalidDecl() || FD->getType()->isDependentType())
16842 return false;
16843
16845 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
16846 CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl());
16847 if (RDecl->getDefinition()) {
16848 // We check for copy constructors before constructors
16849 // because otherwise we'll never get complaints about
16850 // copy constructors.
16851
16853 // We're required to check for any non-trivial constructors. Since the
16854 // implicit default constructor is suppressed if there are any
16855 // user-declared constructors, we just need to check that there is a
16856 // trivial default constructor and a trivial copy constructor. (We don't
16857 // worry about move constructors here, since this is a C++98 check.)
16858 if (RDecl->hasNonTrivialCopyConstructor())
16859 member = CXXCopyConstructor;
16860 else if (!RDecl->hasTrivialDefaultConstructor())
16861 member = CXXDefaultConstructor;
16862 else if (RDecl->hasNonTrivialCopyAssignment())
16863 member = CXXCopyAssignment;
16864 else if (RDecl->hasNonTrivialDestructor())
16865 member = CXXDestructor;
16866
16867 if (member != CXXInvalid) {
16868 if (!getLangOpts().CPlusPlus11 &&
16869 getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) {
16870 // Objective-C++ ARC: it is an error to have a non-trivial field of
16871 // a union. However, system headers in Objective-C programs
16872 // occasionally have Objective-C lifetime objects within unions,
16873 // and rather than cause the program to fail, we make those
16874 // members unavailable.
16875 SourceLocation Loc = FD->getLocation();
16876 if (getSourceManager().isInSystemHeader(Loc)) {
16877 if (!FD->hasAttr<UnavailableAttr>())
16880 return false;
16881 }
16882 }
16883
16885 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
16886 diag::err_illegal_union_or_anon_struct_member)
16887 << FD->getParent()->isUnion() << FD->getDeclName() << member;
16888 DiagnoseNontrivial(RDecl, member);
16889 return !getLangOpts().CPlusPlus11;
16890 }
16891 }
16892 }
16893
16894 return false;
16895}
16896
16897/// TranslateIvarVisibility - Translate visibility from a token ID to an
16898/// AST enum value.
16901 switch (ivarVisibility) {
16902 default: llvm_unreachable("Unknown visitibility kind");
16903 case tok::objc_private: return ObjCIvarDecl::Private;
16904 case tok::objc_public: return ObjCIvarDecl::Public;
16905 case tok::objc_protected: return ObjCIvarDecl::Protected;
16906 case tok::objc_package: return ObjCIvarDecl::Package;
16907 }
16908}
16909
16910/// ActOnIvar - Each ivar field of an objective-c class is passed into this
16911/// in order to create an IvarDecl object for it.
16913 SourceLocation DeclStart,
16914 Declarator &D, Expr *BitfieldWidth,
16916
16917 IdentifierInfo *II = D.getIdentifier();
16918 Expr *BitWidth = (Expr*)BitfieldWidth;
16919 SourceLocation Loc = DeclStart;
16920 if (II) Loc = D.getIdentifierLoc();
16921
16922 // FIXME: Unnamed fields can be handled in various different ways, for
16923 // example, unnamed unions inject all members into the struct namespace!
16924
16925 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
16926 QualType T = TInfo->getType();
16927
16928 if (BitWidth) {
16929 // 6.7.2.1p3, 6.7.2.1p4
16930 BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get();
16931 if (!BitWidth)
16932 D.setInvalidType();
16933 } else {
16934 // Not a bitfield.
16935
16936 // validate II.
16937
16938 }
16939 if (T->isReferenceType()) {
16940 Diag(Loc, diag::err_ivar_reference_type);
16941 D.setInvalidType();
16942 }
16943 // C99 6.7.2.1p8: A member of a structure or union may have any type other
16944 // than a variably modified type.
16945 else if (T->isVariablyModifiedType()) {
16947 *this, TInfo, T, Loc, diag::err_typecheck_ivar_variable_size))
16948 D.setInvalidType();
16949 }
16950
16951 // Get the visibility (access control) for this ivar.
16953 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
16955 // Must set ivar's DeclContext to its enclosing interface.
16957 if (!EnclosingDecl || EnclosingDecl->isInvalidDecl())
16958 return nullptr;
16959 ObjCContainerDecl *EnclosingContext;
16960 if (ObjCImplementationDecl *IMPDecl =
16961 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
16963 // Case of ivar declared in an implementation. Context is that of its class.
16964 EnclosingContext = IMPDecl->getClassInterface();
16965 assert(EnclosingContext && "Implementation has no class interface!");
16966 }
16967 else
16968 EnclosingContext = EnclosingDecl;
16969 } else {
16970 if (ObjCCategoryDecl *CDecl =
16971 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
16972 if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) {
16973 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
16974 return nullptr;
16975 }
16976 }
16977 EnclosingContext = EnclosingDecl;
16978 }
16979
16980 // Construct the decl.
16981 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
16982 DeclStart, Loc, II, T,
16983 TInfo, ac, (Expr *)BitfieldWidth);
16984
16985 if (II) {
16986 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
16988 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
16989 && !isa<TagDecl>(PrevDecl)) {
16990 Diag(Loc, diag::err_duplicate_member) << II;
16991 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
16992 NewID->setInvalidDecl();
16993 }
16994 }
16995
16996 // Process attributes attached to the ivar.
16997 ProcessDeclAttributes(S, NewID, D);
16998
16999 if (D.isInvalidType())
17000 NewID->setInvalidDecl();
17001
17002 // In ARC, infer 'retaining' for ivars of retainable type.
17003 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
17004 NewID->setInvalidDecl();
17005
17007 NewID->setModulePrivate();
17008
17009 if (II) {
17010 // FIXME: When interfaces are DeclContexts, we'll need to add
17011 // these to the interface.
17012 S->AddDecl(NewID);
17013 IdResolver.AddDecl(NewID);
17014 }
17015
17017 !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
17018 Diag(Loc, diag::warn_ivars_in_interface);
17019
17020 return NewID;
17021}
17022
17023/// ActOnLastBitfield - This routine handles synthesized bitfields rules for
17024/// class and class extensions. For every class \@interface and class
17025/// extension \@interface, if the last ivar is a bitfield of any type,
17026/// then add an implicit `char :0` ivar to the end of that interface.
17028 SmallVectorImpl<Decl *> &AllIvarDecls) {
17029 if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty())
17030 return;
17031
17032 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
17033 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
17034
17035 if (!Ivar->isBitField() || Ivar->isZeroLengthBitField(Context))
17036 return;
17037 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
17038 if (!ID) {
17039 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
17040 if (!CD->IsClassExtension())
17041 return;
17042 }
17043 // No need to add this to end of @implementation.
17044 else
17045 return;
17046 }
17047 // All conditions are met. Add a new bitfield to the tail end of ivars.
17048 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
17049 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
17050
17051 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
17052 DeclLoc, DeclLoc, nullptr,
17055 DeclLoc),
17057 true);
17058 AllIvarDecls.push_back(Ivar);
17059}
17060
17061void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl,
17062 ArrayRef<Decl *> Fields, SourceLocation LBrac,
17063 SourceLocation RBrac,
17064 const ParsedAttributesView &Attrs) {
17065 assert(EnclosingDecl && "missing record or interface decl");
17066
17067 // If this is an Objective-C @implementation or category and we have
17068 // new fields here we should reset the layout of the interface since
17069 // it will now change.
17070 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
17071 ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl);
17072 switch (DC->getKind()) {
17073 default: break;
17074 case Decl::ObjCCategory:
17075 Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface());
17076 break;
17077 case Decl::ObjCImplementation:
17078 Context.
17079 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
17080 break;
17081 }
17082 }
17083
17084 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
17085 CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl);
17086
17087 // Start counting up the number of named members; make sure to include
17088 // members of anonymous structs and unions in the total.
17089 unsigned NumNamedMembers = 0;
17090 if (Record) {
17091 for (const auto *I : Record->decls()) {
17092 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
17093 if (IFD->getDeclName())
17094 ++NumNamedMembers;
17095 }
17096 }
17097
17098 // Verify that all the fields are okay.
17100
17101 for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
17102 i != end; ++i) {
17103 FieldDecl *FD = cast<FieldDecl>(*i);
17104
17105 // Get the type for the field.
17106 const Type *FDTy = FD->getType().getTypePtr();
17107
17108 if (!FD->isAnonymousStructOrUnion()) {
17109 // Remember all fields written by the user.
17110 RecFields.push_back(FD);
17111 }
17112
17113 // If the field is already invalid for some reason, don't emit more
17114 // diagnostics about it.
17115 if (FD->isInvalidDecl()) {
17116 EnclosingDecl->setInvalidDecl();
17117 continue;
17118 }
17119
17120 // C99 6.7.2.1p2:
17121 // A structure or union shall not contain a member with
17122 // incomplete or function type (hence, a structure shall not
17123 // contain an instance of itself, but may contain a pointer to
17124 // an instance of itself), except that the last member of a
17125 // structure with more than one named member may have incomplete
17126 // array type; such a structure (and any union containing,
17127 // possibly recursively, a member that is such a structure)
17128 // shall not be a member of a structure or an element of an
17129 // array.
17130 bool IsLastField = (i + 1 == Fields.end());
17131 if (FDTy->isFunctionType()) {
17132 // Field declared as a function.
17133 Diag(FD->getLocation(), diag::err_field_declared_as_function)
17134 << FD->getDeclName();
17135 FD->setInvalidDecl();
17136 EnclosingDecl->setInvalidDecl();
17137 continue;
17138 } else if (FDTy->isIncompleteArrayType() &&
17139 (Record || isa<ObjCContainerDecl>(EnclosingDecl))) {
17140 if (Record) {
17141 // Flexible array member.
17142 // Microsoft and g++ is more permissive regarding flexible array.
17143 // It will accept flexible array in union and also
17144 // as the sole element of a struct/class.
17145 unsigned DiagID = 0;
17146 if (!Record->isUnion() && !IsLastField) {
17147 Diag(FD->getLocation(), diag::err_flexible_array_not_at_end)
17148 << FD->getDeclName() << FD->getType() << Record->getTagKind();
17149 Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration);
17150 FD->setInvalidDecl();
17151 EnclosingDecl->setInvalidDecl();
17152 continue;
17153 } else if (Record->isUnion())
17154 DiagID = getLangOpts().MicrosoftExt
17155 ? diag::ext_flexible_array_union_ms
17156 : getLangOpts().CPlusPlus
17157 ? diag::ext_flexible_array_union_gnu
17158 : diag::err_flexible_array_union;
17159 else if (NumNamedMembers < 1)
17160 DiagID = getLangOpts().MicrosoftExt
17161 ? diag::ext_flexible_array_empty_aggregate_ms
17162 : getLangOpts().CPlusPlus
17163 ? diag::ext_flexible_array_empty_aggregate_gnu
17164 : diag::err_flexible_array_empty_aggregate;
17165
17166 if (DiagID)
17167 Diag(FD->getLocation(), DiagID) << FD->getDeclName()
17168 << Record->getTagKind();
17169 // While the layout of types that contain virtual bases is not specified
17170 // by the C++ standard, both the Itanium and Microsoft C++ ABIs place
17171 // virtual bases after the derived members. This would make a flexible
17172 // array member declared at the end of an object not adjacent to the end
17173 // of the type.
17174 if (CXXRecord && CXXRecord->getNumVBases() != 0)
17175 Diag(FD->getLocation(), diag::err_flexible_array_virtual_base)
17176 << FD->getDeclName() << Record->getTagKind();
17177 if (!getLangOpts().C99)
17178 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
17179 << FD->getDeclName() << Record->getTagKind();
17180
17181 // If the element type has a non-trivial destructor, we would not
17182 // implicitly destroy the elements, so disallow it for now.
17183 //
17184 // FIXME: GCC allows this. We should probably either implicitly delete
17185 // the destructor of the containing class, or just allow this.
17186 QualType BaseElem = Context.getBaseElementType(FD->getType());
17187 if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) {
17188 Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
17189 << FD->getDeclName() << FD->getType();
17190 FD->setInvalidDecl();
17191 EnclosingDecl->setInvalidDecl();
17192 continue;
17193 }
17194 // Okay, we have a legal flexible array member at the end of the struct.
17195 Record->setHasFlexibleArrayMember(true);
17196 } else {
17197 // In ObjCContainerDecl ivars with incomplete array type are accepted,
17198 // unless they are followed by another ivar. That check is done
17199 // elsewhere, after synthesized ivars are known.
17200 }
17201 } else if (!FDTy->isDependentType() &&
17203 FD->getLocation(), FD->getType(),
17204 diag::err_field_incomplete_or_sizeless)) {
17205 // Incomplete type
17206 FD->setInvalidDecl();
17207 EnclosingDecl->setInvalidDecl();
17208 continue;
17209 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
17210 if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
17211 // A type which contains a flexible array member is considered to be a
17212 // flexible array member.
17213 Record->setHasFlexibleArrayMember(true);
17214 if (!Record->isUnion()) {
17215 // If this is a struct/class and this is not the last element, reject
17216 // it. Note that GCC supports variable sized arrays in the middle of
17217 // structures.
17218 if (!IsLastField)
17219 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
17220 << FD->getDeclName() << FD->getType();
17221 else {
17222 // We support flexible arrays at the end of structs in
17223 // other structs as an extension.
17224 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
17225 << FD->getDeclName();
17226 }
17227 }
17228 }
17229 if (isa<ObjCContainerDecl>(EnclosingDecl) &&
17231 diag::err_abstract_type_in_decl,
17233 // Ivars can not have abstract class types
17234 FD->setInvalidDecl();
17235 }
17236 if (Record && FDTTy->getDecl()->hasObjectMember())
17237 Record->setHasObjectMember(true);
17238 if (Record && FDTTy->getDecl()->hasVolatileMember())
17239 Record->setHasVolatileMember(true);
17240 } else if (FDTy->isObjCObjectType()) {
17241 /// A field cannot be an Objective-c object
17242 Diag(FD->getLocation(), diag::err_statically_allocated_object)
17245 FD->setType(T);
17246 } else if (Record && Record->isUnion() &&
17248 getSourceManager().isInSystemHeader(FD->getLocation()) &&
17252 // For backward compatibility, fields of C unions declared in system
17253 // headers that have non-trivial ObjC ownership qualifications are marked
17254 // as unavailable unless the qualifier is explicit and __strong. This can
17255 // break ABI compatibility between programs compiled with ARC and MRR, but
17256 // is a better option than rejecting programs using those unions under
17257 // ARC.
17260 FD->getLocation()));
17261 } else if (getLangOpts().ObjC &&
17262 getLangOpts().getGC() != LangOptions::NonGC && Record &&
17263 !Record->hasObjectMember()) {
17264 if (FD->getType()->isObjCObjectPointerType() ||
17265 FD->getType().isObjCGCStrong())
17266 Record->setHasObjectMember(true);
17267 else if (Context.getAsArrayType(FD->getType())) {
17268 QualType BaseType = Context.getBaseElementType(FD->getType());
17269 if (BaseType->isRecordType() &&
17270 BaseType->castAs<RecordType>()->getDecl()->hasObjectMember())
17271 Record->setHasObjectMember(true);
17272 else if (BaseType->isObjCObjectPointerType() ||
17273 BaseType.isObjCGCStrong())
17274 Record->setHasObjectMember(true);
17275 }
17276 }
17277
17278 if (Record && !getLangOpts().CPlusPlus &&
17279 !shouldIgnoreForRecordTriviality(FD)) {
17280 QualType FT = FD->getType();
17282 Record->setNonTrivialToPrimitiveDefaultInitialize(true);
17284 Record->isUnion())
17285 Record->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(true);
17286 }
17289 Record->setNonTrivialToPrimitiveCopy(true);
17290 if (FT.hasNonTrivialToPrimitiveCopyCUnion() || Record->isUnion())
17291 Record->setHasNonTrivialToPrimitiveCopyCUnion(true);
17292 }
17293 if (FT.isDestructedType()) {
17294 Record->setNonTrivialToPrimitiveDestroy(true);
17295 Record->setParamDestroyedInCallee(true);
17296 if (FT.hasNonTrivialToPrimitiveDestructCUnion() || Record->isUnion())
17297 Record->setHasNonTrivialToPrimitiveDestructCUnion(true);
17298 }
17299
17300 if (const auto *RT = FT->getAs<RecordType>()) {
17301 if (RT->getDecl()->getArgPassingRestrictions() ==
17303 Record->setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs);
17305 Record->setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs);
17306 }
17307
17308 if (Record && FD->getType().isVolatileQualified())
17309 Record->setHasVolatileMember(true);
17310 // Keep track of the number of named members.
17311 if (FD->getIdentifier())
17312 ++NumNamedMembers;
17313 }
17314
17315 // Okay, we successfully defined 'Record'.
17316 if (Record) {
17317 bool Completed = false;
17318 if (CXXRecord) {
17319 if (!CXXRecord->isInvalidDecl()) {
17320 // Set access bits correctly on the directly-declared conversions.
17322 I = CXXRecord->conversion_begin(),
17323 E = CXXRecord->conversion_end(); I != E; ++I)
17324 I.setAccess((*I)->getAccess());
17325 }
17326
17327 // Add any implicitly-declared members to this class.
17329
17330 if (!CXXRecord->isDependentType()) {
17331 if (!CXXRecord->isInvalidDecl()) {
17332 // If we have virtual base classes, we may end up finding multiple
17333 // final overriders for a given virtual function. Check for this
17334 // problem now.
17335 if (CXXRecord->getNumVBases()) {
17336 CXXFinalOverriderMap FinalOverriders;
17337 CXXRecord->getFinalOverriders(FinalOverriders);
17338
17339 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
17340 MEnd = FinalOverriders.end();
17341 M != MEnd; ++M) {
17342 for (OverridingMethods::iterator SO = M->second.begin(),
17343 SOEnd = M->second.end();
17344 SO != SOEnd; ++SO) {
17345 assert(SO->second.size() > 0 &&
17346 "Virtual function without overriding functions?");
17347 if (SO->second.size() == 1)
17348 continue;
17349
17350 // C++ [class.virtual]p2:
17351 // In a derived class, if a virtual member function of a base
17352 // class subobject has more than one final overrider the
17353 // program is ill-formed.
17354 Diag(Record->getLocation(), diag::err_multiple_final_overriders)
17355 << (const NamedDecl *)M->first << Record;
17356 Diag(M->first->getLocation(),
17357 diag::note_overridden_virtual_function);
17359 OM = SO->second.begin(),
17360 OMEnd = SO->second.end();
17361 OM != OMEnd; ++OM)
17362 Diag(OM->Method->getLocation(), diag::note_final_overrider)
17363 << (const NamedDecl *)M->first << OM->Method->getParent();
17364
17365 Record->setInvalidDecl();
17366 }
17367 }
17368 CXXRecord->completeDefinition(&FinalOverriders);
17369 Completed = true;
17370 }
17371 }
17372 }
17373 }
17374
17375 if (!Completed)
17376 Record->completeDefinition();
17377
17378 // Handle attributes before checking the layout.
17379 ProcessDeclAttributeList(S, Record, Attrs);
17380
17381 // We may have deferred checking for a deleted destructor. Check now.
17382 if (CXXRecord) {
17383 auto *Dtor = CXXRecord->getDestructor();
17384 if (Dtor && Dtor->isImplicit() &&
17386 CXXRecord->setImplicitDestructorIsDeleted();
17387 SetDeclDeleted(Dtor, CXXRecord->getLocation());
17388 }
17389 }
17390
17391 if (Record->hasAttrs()) {
17393
17394 if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>())
17395 checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record),
17396 IA->getRange(), IA->getBestCase(),
17397 IA->getInheritanceModel());
17398 }
17399
17400 // Check if the structure/union declaration is a type that can have zero
17401 // size in C. For C this is a language extension, for C++ it may cause
17402 // compatibility problems.
17403 bool CheckForZeroSize;
17404 if (!getLangOpts().CPlusPlus) {
17405 CheckForZeroSize = true;
17406 } else {
17407 // For C++ filter out types that cannot be referenced in C code.
17408 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
17409 CheckForZeroSize =
17410 CXXRecord->getLexicalDeclContext()->isExternCContext() &&
17411 !CXXRecord->isDependentType() && !inTemplateInstantiation() &&
17412 CXXRecord->isCLike();
17413 }
17414 if (CheckForZeroSize) {
17415 bool ZeroSize = true;
17416 bool IsEmpty = true;
17417 unsigned NonBitFields = 0;
17418 for (RecordDecl::field_iterator I = Record->field_begin(),
17419 E = Record->field_end();
17420 (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
17421 IsEmpty = false;
17422 if (I->isUnnamedBitfield()) {
17423 if (!I->isZeroLengthBitField(Context))
17424 ZeroSize = false;
17425 } else {
17426 ++NonBitFields;
17427 QualType FieldType = I->getType();
17428 if (FieldType->isIncompleteType() ||
17429 !Context.getTypeSizeInChars(FieldType).isZero())
17430 ZeroSize = false;
17431 }
17432 }
17433
17434 // Empty structs are an extension in C (C99 6.7.2.1p7). They are
17435 // allowed in C++, but warn if its declaration is inside
17436 // extern "C" block.
17437 if (ZeroSize) {
17438 Diag(RecLoc, getLangOpts().CPlusPlus ?
17439 diag::warn_zero_size_struct_union_in_extern_c :
17440 diag::warn_zero_size_struct_union_compat)
17441 << IsEmpty << Record->isUnion() << (NonBitFields > 1);
17442 }
17443
17444 // Structs without named members are extension in C (C99 6.7.2.1p7),
17445 // but are accepted by GCC.
17446 if (NonBitFields == 0 && !getLangOpts().CPlusPlus) {
17447 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
17448 diag::ext_no_named_members_in_struct_union)
17449 << Record->isUnion();
17450 }
17451 }
17452 } else {
17453 ObjCIvarDecl **ClsFields =
17454 reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
17455 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
17456 ID->setEndOfDefinitionLoc(RBrac);
17457 // Add ivar's to class's DeclContext.
17458 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
17459 ClsFields[i]->setLexicalDeclContext(ID);
17460 ID->addDecl(ClsFields[i]);
17461 }
17462 // Must enforce the rule that ivars in the base classes may not be
17463 // duplicates.
17464 if (ID->getSuperClass())
17465 DiagnoseDuplicateIvars(ID, ID->getSuperClass());
17466 } else if (ObjCImplementationDecl *IMPDecl =
17467 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
17468 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
17469 for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
17470 // Ivar declared in @implementation never belongs to the implementation.
17471 // Only it is in implementation's lexical context.
17472 ClsFields[I]->setLexicalDeclContext(IMPDecl);
17473 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
17474 IMPDecl->setIvarLBraceLoc(LBrac);
17475 IMPDecl->setIvarRBraceLoc(RBrac);
17476 } else if (ObjCCategoryDecl *CDecl =
17477 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
17478 // case of ivars in class extension; all other cases have been
17479 // reported as errors elsewhere.
17480 // FIXME. Class extension does not have a LocEnd field.
17481 // CDecl->setLocEnd(RBrac);
17482 // Add ivar's to class extension's DeclContext.
17483 // Diagnose redeclaration of private ivars.
17484 ObjCInterfaceDecl *IDecl = CDecl->getClassInterface();
17485 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
17486 if (IDecl) {
17487 if (const ObjCIvarDecl *ClsIvar =
17488 IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) {
17489 Diag(ClsFields[i]->getLocation(),
17490 diag::err_duplicate_ivar_declaration);
17491 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
17492 continue;
17493 }
17494 for (const auto *Ext : IDecl->known_extensions()) {
17495 if (const ObjCIvarDecl *ClsExtIvar
17496 = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) {
17497 Diag(ClsFields[i]->getLocation(),
17498 diag::err_duplicate_ivar_declaration);
17499 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
17500 continue;
17501 }
17502 }
17503 }
17504 ClsFields[i]->setLexicalDeclContext(CDecl);
17505 CDecl->addDecl(ClsFields[i]);
17506 }
17507 CDecl->setIvarLBraceLoc(LBrac);
17508 CDecl->setIvarRBraceLoc(RBrac);
17509 }
17510 }
17511}
17512
17513/// Determine whether the given integral value is representable within
17514/// the given type T.
17516 llvm::APSInt &Value,
17517 QualType T) {
17518 assert((T->isIntegralType(Context) || T->isEnumeralType()) &&
17519 "Integral type required!");
17520 unsigned BitWidth = Context.getIntWidth(T);
17521
17522 if (Value.isUnsigned() || Value.isNonNegative()) {
17523 if (T->isSignedIntegerOrEnumerationType())
17524 --BitWidth;
17525 return Value.getActiveBits() <= BitWidth;
17526 }
17527 return Value.getMinSignedBits() <= BitWidth;
17528}
17529
17530// Given an integral type, return the next larger integral type
17531// (or a NULL type of no such type exists).
17533 // FIXME: Int128/UInt128 support, which also needs to be introduced into
17534 // enum checking below.
17535 assert((T->isIntegralType(Context) ||
17536 T->isEnumeralType()) && "Integral type required!");
17537 const unsigned NumTypes = 4;
17538 QualType SignedIntegralTypes[NumTypes] = {
17539 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
17540 };
17541 QualType UnsignedIntegralTypes[NumTypes] = {
17542 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
17543 Context.UnsignedLongLongTy
17544 };
17545
17546 unsigned BitWidth = Context.getTypeSize(T);
17547 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
17548 : UnsignedIntegralTypes;
17549 for (unsigned I = 0; I != NumTypes; ++I)
17550 if (Context.getTypeSize(Types[I]) > BitWidth)
17551 return Types[I];
17552
17553 return QualType();
17554}
17555
17557 EnumConstantDecl *LastEnumConst,
17558 SourceLocation IdLoc,
17560 Expr *Val) {
17561 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
17562 llvm::APSInt EnumVal(IntWidth);
17563 QualType EltTy;
17564
17566 Val = nullptr;
17567
17568 if (Val)
17569 Val = DefaultLvalueConversion(Val).get();
17570
17571 if (Val) {
17572 if (Enum->isDependentType() || Val->isTypeDependent())
17573 EltTy = Context.DependentTy;
17574 else {
17575 // FIXME: We don't allow folding in C++11 mode for an enum with a fixed
17576 // underlying type, but do allow it in all other contexts.
17577 if (getLangOpts().CPlusPlus11 && Enum->isFixed()) {
17578 // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the
17579 // constant-expression in the enumerator-definition shall be a converted
17580 // constant expression of the underlying type.
17581 EltTy = Enum->getIntegerType();
17582 ExprResult Converted =
17583 CheckConvertedConstantExpression(Val, EltTy, EnumVal,
17585 if (Converted.isInvalid())
17586 Val = nullptr;
17587 else
17588 Val = Converted.get();
17589 } else if (!Val->isValueDependent() &&
17590 !(Val =
17592 .get())) {
17593 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
17594 } else {
17595 if (Enum->isComplete()) {
17596 EltTy = Enum->getIntegerType();
17597
17598 // In Obj-C and Microsoft mode, require the enumeration value to be
17599 // representable in the underlying type of the enumeration. In C++11,
17600 // we perform a non-narrowing conversion as part of converted constant
17601 // expression checking.
17602 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
17604 .getTriple()
17605 .isWindowsMSVCEnvironment()) {
17606 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
17607 } else {
17608 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
17609 }
17610 }
17611
17612 // Cast to the underlying type.
17613 Val = ImpCastExprToType(Val, EltTy,
17614 EltTy->isBooleanType() ? CK_IntegralToBoolean
17615 : CK_IntegralCast)
17616 .get();
17617 } else if (getLangOpts().CPlusPlus) {
17618 // C++11 [dcl.enum]p5:
17619 // If the underlying type is not fixed, the type of each enumerator
17620 // is the type of its initializing value:
17621 // - If an initializer is specified for an enumerator, the
17622 // initializing value has the same type as the expression.
17623 EltTy = Val->getType();
17624 } else {
17625 // C99 6.7.2.2p2:
17626 // The expression that defines the value of an enumeration constant
17627 // shall be an integer constant expression that has a value
17628 // representable as an int.
17629
17630 // Complain if the value is not representable in an int.
17632 Diag(IdLoc, diag::ext_enum_value_not_int)
17633 << EnumVal.toString(10) << Val->getSourceRange()
17634 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
17635 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
17636 // Force the type of the expression to 'int'.
17637 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
17638 }
17639 EltTy = Val->getType();
17640 }
17641 }
17642 }
17643 }
17644
17645 if (!Val) {
17646 if (Enum->isDependentType())
17647 EltTy = Context.DependentTy;
17648 else if (!LastEnumConst) {
17649 // C++0x [dcl.enum]p5:
17650 // If the underlying type is not fixed, the type of each enumerator
17651 // is the type of its initializing value:
17652 // - If no initializer is specified for the first enumerator, the
17653 // initializing value has an unspecified integral type.
17654 //
17655 // GCC uses 'int' for its unspecified integral type, as does
17656 // C99 6.7.2.2p3.
17657 if (Enum->isFixed()) {
17658 EltTy = Enum->getIntegerType();
17659 }
17660 else {
17661 EltTy = Context.IntTy;
17662 }
17663 } else {
17664 // Assign the last value + 1.
17665 EnumVal = LastEnumConst->getInitVal();
17666 ++EnumVal;
17667 EltTy = LastEnumConst->getType();
17668
17669 // Check for overflow on increment.
17670 if (EnumVal < LastEnumConst->getInitVal()) {
17671 // C++0x [dcl.enum]p5:
17672 // If the underlying type is not fixed, the type of each enumerator
17673 // is the type of its initializing value:
17674 //
17675 // - Otherwise the type of the initializing value is the same as
17676 // the type of the initializing value of the preceding enumerator
17677 // unless the incremented value is not representable in that type,
17678 // in which case the type is an unspecified integral type
17679 // sufficient to contain the incremented value. If no such type
17680 // exists, the program is ill-formed.
17682 if (T.isNull() || Enum->isFixed()) {
17683 // There is no integral type larger enough to represent this
17684 // value. Complain, then allow the value to wrap around.
17685 EnumVal = LastEnumConst->getInitVal();
17686 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
17687 ++EnumVal;
17688 if (Enum->isFixed())
17689 // When the underlying type is fixed, this is ill-formed.
17690 Diag(IdLoc, diag::err_enumerator_wrapped)
17691 << EnumVal.toString(10)
17692 << EltTy;
17693 else
17694 Diag(IdLoc, diag::ext_enumerator_increment_too_large)
17695 << EnumVal.toString(10);
17696 } else {
17697 EltTy = T;
17698 }
17699
17700 // Retrieve the last enumerator's value, extent that type to the
17701 // type that is supposed to be large enough to represent the incremented
17702 // value, then increment.
17703 EnumVal = LastEnumConst->getInitVal();
17704 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
17705 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
17706 ++EnumVal;
17707
17708 // If we're not in C++, diagnose the overflow of enumerator values,
17709 // which in C99 means that the enumerator value is not representable in
17710 // an int (C99 6.7.2.2p2). However, we support GCC's extension that
17711 // permits enumerator values that are representable in some larger
17712 // integral type.
17713 if (!getLangOpts().CPlusPlus && !T.isNull())
17714 Diag(IdLoc, diag::warn_enum_value_overflow);
17715 } else if (!getLangOpts().CPlusPlus &&
17716 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
17717 // Enforce C99 6.7.2.2p2 even when we compute the next value.
17718 Diag(IdLoc, diag::ext_enum_value_not_int)
17719 << EnumVal.toString(10) << 1;
17720 }
17721 }
17722 }
17723
17724 if (!EltTy->isDependentType()) {
17725 // Make the enumerator value match the signedness and size of the
17726 // enumerator's type.
17727 EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy));
17728 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
17729 }
17730
17731 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
17732 Val, EnumVal);
17733}
17734
17736 SourceLocation IILoc) {
17737 if (!(getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) ||
17739 return SkipBodyInfo();
17740
17741 // We have an anonymous enum definition. Look up the first enumerator to
17742 // determine if we should merge the definition with an existing one and
17743 // skip the body.
17744 NamedDecl *PrevDecl = LookupSingleName(S, II, IILoc, LookupOrdinaryName,
17746 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
17747 if (!PrevECD)
17748 return SkipBodyInfo();
17749
17750 EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext());
17751 NamedDecl *Hidden;
17752 if (!PrevED->getDeclName() && !hasVisibleDefinition(PrevED, &Hidden)) {
17753 SkipBodyInfo Skip;
17754 Skip.Previous = Hidden;
17755 return Skip;
17756 }
17757
17758 return SkipBodyInfo();
17759}
17760
17761Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst,
17763 const ParsedAttributesView &Attrs,
17764 SourceLocation EqualLoc, Expr *Val) {
17765 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
17766 EnumConstantDecl *LastEnumConst =
17767 cast_or_null<EnumConstantDecl>(lastEnumConst);
17768
17769 // The scope passed in may not be a decl scope. Zip up the scope tree until
17770 // we find one that is.
17771 S = getNonFieldDeclScope(S);
17772
17773 // Verify that there isn't already something declared with this name in this
17774 // scope.
17776 LookupName(R, S);
17777 NamedDecl *PrevDecl = R.getAsSingle<NamedDecl>();
17778
17779 if (PrevDecl && PrevDecl->isTemplateParameter()) {
17780 // Maybe we will complain about the shadowed template parameter.
17781 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
17782 // Just pretend that we didn't see the previous declaration.
17783 PrevDecl = nullptr;
17784 }
17785
17786 // C++ [class.mem]p15:
17787 // If T is the name of a class, then each of the following shall have a name
17788 // different from T:
17789 // - every enumerator of every member of class T that is an unscoped
17790 // enumerated type
17791 if (getLangOpts().CPlusPlus && !TheEnumDecl->isScoped())
17793 DeclarationNameInfo(Id, IdLoc));
17794
17795 EnumConstantDecl *New =
17796 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
17797 if (!New)
17798 return nullptr;
17799
17800 if (PrevDecl) {
17801 if (!TheEnumDecl->isScoped() && isa<ValueDecl>(PrevDecl)) {
17802 // Check for other kinds of shadowing not already handled.
17803 CheckShadow(New, PrevDecl, R);
17804 }
17805
17806 // When in C++, we may get a TagDecl with the same name; in this case the
17807 // enum constant will 'hide' the tag.
17808 assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
17809 "Received TagDecl when not in C++!");
17810 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
17811 if (isa<EnumConstantDecl>(PrevDecl))
17812 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
17813 else
17814 Diag(IdLoc, diag::err_redefinition) << Id;
17815 notePreviousDefinition(PrevDecl, IdLoc);
17816 return nullptr;
17817 }
17818 }
17819
17820 // Process attributes.
17821 ProcessDeclAttributeList(S, New, Attrs);
17822 AddPragmaAttributes(S, New);
17823
17824 // Register this decl in the current scope stack.
17825 New->setAccess(TheEnumDecl->getAccess());
17826 PushOnScopeChains(New, S);
17827
17829
17830 return New;
17831}
17832
17833// Returns true when the enum initial expression does not trigger the
17834// duplicate enum warning. A few common cases are exempted as follows:
17835// Element2 = Element1
17836// Element2 = Element1 + 1
17837// Element2 = Element1 - 1
17838// Where Element2 and Element1 are from the same enum.
17840 Expr *InitExpr = ECD->getInitExpr();
17841 if (!InitExpr)
17842 return true;
17843 InitExpr = InitExpr->IgnoreImpCasts();
17844
17845 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) {
17846 if (!BO->isAdditiveOp())
17847 return true;
17848 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS());
17849 if (!IL)
17850 return true;
17851 if (IL->getValue() != 1)
17852 return true;
17853
17854 InitExpr = BO->getLHS();
17855 }
17856
17857 // This checks if the elements are from the same enum.
17858 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
17859 if (!DRE)
17860 return true;
17861
17862 EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl());
17863 if (!EnumConstant)
17864 return true;
17865
17866 if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) !=
17867 Enum)
17868 return true;
17869
17870 return false;
17871}
17872
17873// Emits a warning when an element is implicitly set a value that
17874// a previous element has already been set to.
17877 // Avoid anonymous enums
17878 if (!Enum->getIdentifier())
17879 return;
17880
17881 // Only check for small enums.
17882 if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64)
17883 return;
17884
17885 if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation()))
17886 return;
17887
17888 typedef SmallVector<EnumConstantDecl *, 3> ECDVector;
17889 typedef SmallVector<std::unique_ptr<ECDVector>, 3> DuplicatesVector;
17890
17891 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
17892
17893 // DenseMaps cannot contain the all ones int64_t value, so use unordered_map.
17894 typedef std::unordered_map<int64_t, DeclOrVector> ValueToVectorMap;
17895
17896 // Use int64_t as a key to avoid needing special handling for map keys.
17897 auto EnumConstantToKey = [](const EnumConstantDecl *D) {
17898 llvm::APSInt Val = D->getInitVal();
17899 return Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue();
17900 };
17901
17902 DuplicatesVector DupVector;
17903 ValueToVectorMap EnumMap;
17904
17905 // Populate the EnumMap with all values represented by enum constants without
17906 // an initializer.
17907 for (auto *Element : Elements) {
17908 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Element);
17909
17910 // Null EnumConstantDecl means a previous diagnostic has been emitted for
17911 // this constant. Skip this enum since it may be ill-formed.
17912 if (!ECD) {
17913 return;
17914 }
17915
17916 // Constants with initalizers are handled in the next loop.
17917 if (ECD->getInitExpr())
17918 continue;
17919
17920 // Duplicate values are handled in the next loop.
17921 EnumMap.insert({EnumConstantToKey(ECD), ECD});
17922 }
17923
17924 if (EnumMap.size() == 0)
17925 return;
17926
17927 // Create vectors for any values that has duplicates.
17928 for (auto *Element : Elements) {
17929 // The last loop returned if any constant was null.
17931 if (!ValidDuplicateEnum(ECD, Enum))
17932 continue;
17933
17934 auto Iter = EnumMap.find(EnumConstantToKey(ECD));
17935 if (Iter == EnumMap.end())
17936 continue;
17937
17938 DeclOrVector& Entry = Iter->second;
17939 if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) {
17940 // Ensure constants are different.
17941 if (D == ECD)
17942 continue;
17943
17944 // Create new vector and push values onto it.
17945 auto Vec = std::make_unique<ECDVector>();
17946 Vec->push_back(D);
17947 Vec->push_back(ECD);
17948
17949 // Update entry to point to the duplicates vector.
17950 Entry = Vec.get();
17951
17952 // Store the vector somewhere we can consult later for quick emission of
17953 // diagnostics.
17954 DupVector.emplace_back(std::move(Vec));
17955 continue;
17956 }
17957
17958 ECDVector *Vec = Entry.get<ECDVector*>();
17959 // Make sure constants are not added more than once.
17960 if (*Vec->begin() == ECD)
17961 continue;
17962
17963 Vec->push_back(ECD);
17964 }
17965
17966 // Emit diagnostics.
17967 for (const auto &Vec : DupVector) {
17968 assert(Vec->size() > 1 && "ECDVector should have at least 2 elements.");
17969
17970 // Emit warning for one enum constant.
17971 auto *FirstECD = Vec->front();
17972 S.Diag(FirstECD->getLocation(), diag::warn_duplicate_enum_values)
17973 << FirstECD << FirstECD->getInitVal().toString(10)
17974 << FirstECD->getSourceRange();
17975
17976 // Emit one note for each of the remaining enum constants with
17977 // the same value.
17978 for (auto *ECD : llvm::make_range(Vec->begin() + 1, Vec->end()))
17979 S.Diag(ECD->getLocation(), diag::note_duplicate_element)
17980 << ECD << ECD->getInitVal().toString(10)
17981 << ECD->getSourceRange();
17982 }
17983}
17984
17985bool Sema::IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
17986 bool AllowMask) const {
17987 assert(ED->isClosedFlag() && "looking for value in non-flag or open enum");
17988 assert(ED->isCompleteDefinition() && "expected enum definition");
17989
17990 auto R = FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
17991 llvm::APInt &FlagBits = R.first->second;
17992
17993 if (R.second) {
17994 for (auto *E : ED->enumerators()) {
17995 const auto &EVal = E->getInitVal();
17996 // Only single-bit enumerators introduce new flag values.
17997 if (EVal.isPowerOf2())
17998 FlagBits = FlagBits.zextOrSelf(EVal.getBitWidth()) | EVal;
17999 }
18000 }
18001
18002 // A value is in a flag enum if either its bits are a subset of the enum's
18003 // flag bits (the first condition) or we are allowing masks and the same is
18004 // true of its complement (the second condition). When masks are allowed, we
18005 // allow the common idiom of ~(enum1 | enum2) to be a valid enum value.
18006 //
18007 // While it's true that any value could be used as a mask, the assumption is
18008 // that a mask will have all of the insignificant bits set. Anything else is
18009 // likely a logic error.
18010 llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
18011 return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val));
18012}
18013
18015 Decl *EnumDeclX, ArrayRef<Decl *> Elements, Scope *S,
18016 const ParsedAttributesView &Attrs) {
18017 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
18019
18020 ProcessDeclAttributeList(S, Enum, Attrs);
18021
18022 if (Enum->isDependentType()) {
18023 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
18024 EnumConstantDecl *ECD =
18025 cast_or_null<EnumConstantDecl>(Elements[i]);
18026 if (!ECD) continue;
18027
18028 ECD->setType(EnumType);
18029 }
18030
18031 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0);
18032 return;
18033 }
18034
18035 // TODO: If the result value doesn't fit in an int, it must be a long or long
18036 // long value. ISO C does not support this, but GCC does as an extension,
18037 // emit a warning.
18038 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
18039 unsigned CharWidth = Context.getTargetInfo().getCharWidth();
18040 unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
18041
18042 // Verify that all the values are okay, compute the size of the values, and
18043 // reverse the list.
18044 unsigned NumNegativeBits = 0;
18045 unsigned NumPositiveBits = 0;
18046
18047 // Keep track of whether all elements have type int.
18048 bool AllElementsInt = true;
18049
18050 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
18051 EnumConstantDecl *ECD =
18052 cast_or_null<EnumConstantDecl>(Elements[i]);
18053 if (!ECD) continue; // Already issued a diagnostic.
18054
18055 const llvm::APSInt &InitVal = ECD->getInitVal();
18056
18057 // Keep track of the size of positive and negative values.
18058 if (InitVal.isUnsigned() || InitVal.isNonNegative())
18059 NumPositiveBits = std::max(NumPositiveBits,
18060 (unsigned)InitVal.getActiveBits());
18061 else
18062 NumNegativeBits = std::max(NumNegativeBits,
18063 (unsigned)InitVal.getMinSignedBits());
18064
18065 // Keep track of whether every enum element has type int (very common).
18066 if (AllElementsInt)
18067 AllElementsInt = ECD->getType() == Context.IntTy;
18068 }
18069
18070 // Figure out the type that should be used for this enum.
18071 QualType BestType;
18072 unsigned BestWidth;
18073
18074 // C++0x N3000 [conv.prom]p3:
18075 // An rvalue of an unscoped enumeration type whose underlying
18076 // type is not fixed can be converted to an rvalue of the first
18077 // of the following types that can represent all the values of
18078 // the enumeration: int, unsigned int, long int, unsigned long
18079 // int, long long int, or unsigned long long int.
18080 // C99 6.4.4.3p2:
18081 // An identifier declared as an enumeration constant has type int.
18082 // The C99 rule is modified by a gcc extension
18083 QualType BestPromotionType;
18084
18085 bool Packed = Enum->hasAttr<PackedAttr>();
18086 // -fshort-enums is the equivalent to specifying the packed attribute on all
18087 // enum definitions.
18088 if (LangOpts.ShortEnums)
18089 Packed = true;
18090
18091 // If the enum already has a type because it is fixed or dictated by the
18092 // target, promote that type instead of analyzing the enumerators.
18093 if (Enum->isComplete()) {
18094 BestType = Enum->getIntegerType();
18095 if (BestType->isPromotableIntegerType())
18096 BestPromotionType = Context.getPromotedIntegerType(BestType);
18097 else
18098 BestPromotionType = BestType;
18099
18100 BestWidth = Context.getIntWidth(BestType);
18101 }
18102 else if (NumNegativeBits) {
18103 // If there is a negative value, figure out the smallest integer type (of
18104 // int/long/longlong) that fits.
18105 // If it's packed, check also if it fits a char or a short.
18106 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
18107 BestType = Context.SignedCharTy;
18108 BestWidth = CharWidth;
18109 } else if (Packed && NumNegativeBits <= ShortWidth &&
18110 NumPositiveBits < ShortWidth) {
18111 BestType = Context.ShortTy;
18112 BestWidth = ShortWidth;
18113 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
18114 BestType = Context.IntTy;
18115 BestWidth = IntWidth;
18116 } else {
18117 BestWidth = Context.getTargetInfo().getLongWidth();
18118
18119 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
18120 BestType = Context.LongTy;
18121 } else {
18122 BestWidth = Context.getTargetInfo().getLongLongWidth();
18123
18124 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
18125 Diag(Enum->getLocation(), diag::ext_enum_too_large);
18126 BestType = Context.LongLongTy;
18127 }
18128 }
18129 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
18130 } else {
18131 // If there is no negative value, figure out the smallest type that fits
18132 // all of the enumerator values.
18133 // If it's packed, check also if it fits a char or a short.
18134 if (Packed && NumPositiveBits <= CharWidth) {
18135 BestType = Context.UnsignedCharTy;
18136 BestPromotionType = Context.IntTy;
18137 BestWidth = CharWidth;
18138 } else if (Packed && NumPositiveBits <= ShortWidth) {
18139 BestType = Context.UnsignedShortTy;
18140 BestPromotionType = Context.IntTy;
18141 BestWidth = ShortWidth;
18142 } else if (NumPositiveBits <= IntWidth) {
18143 BestType = Context.UnsignedIntTy;
18144 BestWidth = IntWidth;
18145 BestPromotionType
18146 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
18148 } else if (NumPositiveBits <=
18149 (BestWidth = Context.getTargetInfo().getLongWidth())) {
18150 BestType = Context.UnsignedLongTy;
18151 BestPromotionType
18152 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
18154 } else {
18155 BestWidth = Context.getTargetInfo().getLongLongWidth();
18156 assert(NumPositiveBits <= BestWidth &&
18157 "How could an initializer get larger than ULL?");
18158 BestType = Context.UnsignedLongLongTy;
18159 BestPromotionType
18160 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
18162 }
18163 }
18164
18165 // Loop over all of the enumerator constants, changing their types to match
18166 // the type of the enum if needed.
18167 for (auto *D : Elements) {
18168 auto *ECD = cast_or_null<EnumConstantDecl>(D);
18169 if (!ECD) continue; // Already issued a diagnostic.
18170
18171 // Standard C says the enumerators have int type, but we allow, as an
18172 // extension, the enumerators to be larger than int size. If each
18173 // enumerator value fits in an int, type it as an int, otherwise type it the
18174 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
18175 // that X has type 'int', not 'unsigned'.
18176
18177 // Determine whether the value fits into an int.
18178 llvm::APSInt InitVal = ECD->getInitVal();
18179
18180 // If it fits into an integer type, force it. Otherwise force it to match
18181 // the enum decl type.
18182 QualType NewTy;
18183 unsigned NewWidth;
18184 bool NewSign;
18185 if (!getLangOpts().CPlusPlus &&
18186 !Enum->isFixed() &&
18188 NewTy = Context.IntTy;
18189 NewWidth = IntWidth;
18190 NewSign = true;
18191 } else if (ECD->getType() == BestType) {
18192 // Already the right type!
18193 if (getLangOpts().CPlusPlus)
18194 // C++ [dcl.enum]p4: Following the closing brace of an
18195 // enum-specifier, each enumerator has the type of its
18196 // enumeration.
18197 ECD->setType(EnumType);
18198 continue;
18199 } else {
18200 NewTy = BestType;
18201 NewWidth = BestWidth;
18202 NewSign = BestType->isSignedIntegerOrEnumerationType();
18203 }
18204
18205 // Adjust the APSInt value.
18206 InitVal = InitVal.extOrTrunc(NewWidth);
18207 InitVal.setIsSigned(NewSign);
18208 ECD->setInitVal(InitVal);
18209
18210 // Adjust the Expr initializer and type.
18211 if (ECD->getInitExpr() &&
18212 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
18213 ECD->setInitExpr(ImplicitCastExpr::Create(
18214 Context, NewTy, CK_IntegralCast, ECD->getInitExpr(),
18215 /*base paths*/ nullptr, VK_RValue, FPOptionsOverride()));
18216 if (getLangOpts().CPlusPlus)
18217 // C++ [dcl.enum]p4: Following the closing brace of an
18218 // enum-specifier, each enumerator has the type of its
18219 // enumeration.
18220 ECD->setType(EnumType);
18221 else
18222 ECD->setType(NewTy);
18223 }
18224
18225 Enum->completeDefinition(BestType, BestPromotionType,
18226 NumPositiveBits, NumNegativeBits);
18227
18228 CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType);
18229
18230 if (Enum->isClosedFlag()) {
18231 for (Decl *D : Elements) {
18232 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(D);
18233 if (!ECD) continue; // Already issued a diagnostic.
18234
18235 llvm::APSInt InitVal = ECD->getInitVal();
18236 if (InitVal != 0 && !InitVal.isPowerOf2() &&
18237 !IsValueInFlagEnum(Enum, InitVal, true))
18238 Diag(ECD->getLocation(), diag::warn_flag_enum_constant_out_of_range)
18239 << ECD << Enum;
18240 }
18241 }
18242
18243 // Now that the enum type is defined, ensure it's not been underaligned.
18244 if (Enum->hasAttrs())
18246}
18247
18249 SourceLocation StartLoc,
18250 SourceLocation EndLoc) {
18252
18254 AsmString, StartLoc,
18255 EndLoc);
18256 CurContext->addDecl(New);
18257 return New;
18258}
18259
18261 IdentifierInfo* AliasName,
18262 SourceLocation PragmaLoc,
18263 SourceLocation NameLoc,
18264 SourceLocation AliasNameLoc) {
18265 NamedDecl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc,
18267 AttributeCommonInfo Info(AliasName, SourceRange(AliasNameLoc),
18270 Context, AliasName->getName(), /*LiteralLabel=*/true, Info);
18271
18272 // If a declaration that:
18273 // 1) declares a function or a variable
18274 // 2) has external linkage
18275 // already exists, add a label attribute to it.
18276 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
18277 if (isDeclExternC(PrevDecl))
18278 PrevDecl->addAttr(Attr);
18279 else
18280 Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied)
18281 << /*Variable*/(isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
18282 // Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers.
18283 } else
18284 (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr));
18285}
18286
18288 SourceLocation PragmaLoc,
18289 SourceLocation NameLoc) {
18290 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
18291
18292 if (PrevDecl) {
18294 } else {
18295 (void)WeakUndeclaredIdentifiers.insert(
18296 std::pair<IdentifierInfo*,WeakInfo>
18297 (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc)));
18298 }
18299}
18300
18302 IdentifierInfo* AliasName,
18303 SourceLocation PragmaLoc,
18304 SourceLocation NameLoc,
18305 SourceLocation AliasNameLoc) {
18306 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
18308 WeakInfo W = WeakInfo(Name, NameLoc);
18309
18310 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
18311 if (!PrevDecl->hasAttr<AliasAttr>())
18312 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
18314 } else {
18315 (void)WeakUndeclaredIdentifiers.insert(
18316 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
18317 }
18318}
18319
18321 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
18322}
18323
18325 bool Final) {
18326 // SYCL functions can be template, so we check if they have appropriate
18327 // attribute prior to checking if it is a template.
18328 if (LangOpts.SYCLIsDevice && FD->hasAttr<SYCLKernelAttr>())
18330
18331 // Templates are emitted when they're instantiated.
18332 if (FD->isDependentContext())
18334
18335 // Check whether this function is an externally visible definition.
18336 auto IsEmittedForExternalSymbol = [this, FD]() {
18337 // We have to check the GVA linkage of the function's *definition* -- if we
18338 // only have a declaration, we don't know whether or not the function will
18339 // be emitted, because (say) the definition could include "inline".
18340 FunctionDecl *Def = FD->getDefinition();
18341
18342 return Def && !isDiscardableGVALinkage(
18343 getASTContext().GetGVALinkageForFunction(Def));
18344 };
18345
18346 if (LangOpts.OpenMPIsDevice) {
18347 // In OpenMP device mode we will not emit host only functions, or functions
18348 // we don't need due to their linkage.
18351 // DevTy may be changed later by
18352 // #pragma omp declare target to(*) device_type(*).
18353 // Therefore DevTyhaving no value does not imply host. The emission status
18354 // will be checked again at the end of compilation unit with Final = true.
18355 if (DevTy.hasValue())
18358 // If we have an explicit value for the device type, or we are in a target
18359 // declare context, we need to emit all extern and used symbols.
18360 if (isInOpenMPDeclareTargetContext() || DevTy.hasValue())
18361 if (IsEmittedForExternalSymbol())
18363 // Device mode only emits what it must, if it wasn't tagged yet and needed,
18364 // we'll omit it.
18365 if (Final)
18367 } else if (LangOpts.OpenMP > 45) {
18368 // In OpenMP host compilation prior to 5.0 everything was an emitted host
18369 // function. In 5.0, no_host was introduced which might cause a function to
18370 // be ommitted.
18373 if (DevTy.hasValue())
18376 }
18377
18378 if (Final && LangOpts.OpenMP && !LangOpts.CUDA)
18380
18381 if (LangOpts.CUDA) {
18382 // When compiling for device, host functions are never emitted. Similarly,
18383 // when compiling for host, device and global functions are never emitted.
18384 // (Technically, we do emit a host-side stub for global functions, but this
18385 // doesn't count for our purposes here.)
18387 if (LangOpts.CUDAIsDevice && T == Sema::CFT_Host)
18389 if (!LangOpts.CUDAIsDevice &&
18390 (T == Sema::CFT_Device || T == Sema::CFT_Global))
18392
18393 if (IsEmittedForExternalSymbol())
18395 }
18396
18397 // Otherwise, the function is known-emitted if it's in our set of
18398 // known-emitted functions.
18400}
18401
18403 // Host-side references to a __global__ function refer to the stub, so the
18404 // function itself is never emitted and therefore should not be marked.
18405 // If we have host fn calls kernel fn calls host+device, the HD function
18406 // does not get instantiated on the host. We model this by omitting at the
18407 // call to the kernel from the callgraph. This ensures that, when compiling
18408 // for host, only HD functions actually called from the host get marked as
18409 // known-emitted.
18410 return LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
18411 IdentifyCUDATarget(Callee) == CFT_Global;
18412}
Defines the clang::ASTContext interface.
NodeId Parent
Definition ASTDiff.cpp:192
int Id
Definition ASTDiff.cpp:191
This file provides some common utility functions for processing Lambda related AST Constructs.
MatchType Type
StringRef P
static unsigned isEnabled(DiagnosticsEngine &D, unsigned diag)
#define SM(sm)
Definition Cuda.cpp:62
auto * N
static const Builtin::Info BuiltinInfo[]
Definition Builtins.cpp:20
Defines enum values for all the target-independent builtin functions.
llvm::Error Error
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
This file defines the classes used to store parsed information about declaration-specifiers and decla...
Defines the C++ template declaration subclasses.
static bool isDeclExternC(const T &D)
Definition Decl.cpp:2072
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
Defines the clang::Expr interface and subclasses for C++ expressions.
TokenType getType() const
Returns the token's type, e.g.
FormatToken * Previous
The previous token in the unwrapped line.
FormatToken * Next
The next token in the unwrapped line.
static const Decl * getCanonicalDecl(const Decl *D)
static bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
Definition Interp.cpp:34
static const GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs)
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
static bool isExternC(const NamedDecl *ND)
Definition Mangle.cpp:58
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
static bool hasAttr(const FunctionDecl *D, bool IgnoreImplicitAttr)
Definition SemaCUDA.cpp:100
static bool isFunctionOrMethod(const Decl *D)
isFunctionOrMethod - Return true if the given decl has function type (function or function-typed vari...
static void diagnoseImplicitlyRetainedSelf(Sema &S)
static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D)
static UnqualifiedTypeNameLookupResult lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc, const CXXRecordDecl *RD)
Tries to perform unqualified lookup of the type decls in bases for dependent class.
Definition SemaDecl.cpp:181
static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype)
static bool PreviousDeclsHaveMultiVersionAttribute(const FunctionDecl *FD)
static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc)
Definition SemaDecl.cpp:236
static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S)
static void adjustDeclContextForDeclaratorDecl(DeclaratorDecl *NewD, DeclaratorDecl *OldD)
If necessary, adjust the semantic declaration context for a qualified declaration to name the correct...
static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken)
Determine whether the given result set contains either a type name or.
Definition SemaDecl.cpp:773
static void FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL)
static TypeSourceInfo * TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID, ASTContext::GetBuiltinTypeError Error)
static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D)
static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New)
Check whether a redeclaration of an entity introduced by a using-declaration is valid,...
static bool mergeDeclAttribute(Sema &S, NamedDecl *D, const InheritableAttr *Attr, Sema::AvailabilityMergeKind AMK)
static ShadowedDeclKind computeShadowedDeclKind(const NamedDecl *ShadowedDecl, const DeclContext *OldDC)
Determine what kind of declaration we're shadowing.
static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl< const Type * > &ValidTypes)
static void mergeParamDeclAttributes(ParmVarDecl *newDecl, const ParmVarDecl *oldDecl, Sema &S)
mergeParamDeclAttributes - Copy attributes from the old parameter to the new one.
static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old)
Merge alignment attributes from Old to New, taking into account the special semantics of C11's _Align...
static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, LookupResult &Previous)
static bool CheckTargetCausesMultiVersioning(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, const TargetAttr *NewTA, bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious, LookupResult &Previous)
static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, FixItHint &Hint)
static NestedNameSpecifier * synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC)
Definition SemaDecl.cpp:526
static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD)
Given that we are within the definition of the given function, will that definition behave like C99's...
static bool isRepresentableIntegerValue(ASTContext &Context, llvm::APSInt &Value, QualType T)
Determine whether the given integral value is representable within the given type T.
static void CheckForDuplicateEnumValues(Sema &S, ArrayRef< Decl * > Elements, EnumDecl *Enum, QualType EnumType)
static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old)
checkNewAttributesAfterDef - If we already have a definition, check that there are no new attributes ...
static bool isClassCompatTagKind(TagTypeKind Tag)
Determine if tag kind is a class-key compatible with class for redeclaration (class,...
static bool tryToFixVariablyModifiedVarType(Sema &S, TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID)
Attempt to fold a variable-sized type to a constant-sized type, returning true if we were successful.
static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A, const FunctionDecl *B)
static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND)
static bool hasSimilarParameters(ASTContext &Context, FunctionDecl *Declaration, FunctionDecl *Definition, SmallVectorImpl< unsigned > &Params)
hasSimilarParameters - Determine whether the C++ functions Declaration and Definition have "nearly" m...
static NonCLikeKind getNonCLikeKindForAnonymousStruct(const CXXRecordDecl *RD)
Determine whether a class is C-like, according to the rules of C++ [dcl.typedef] for anonymous classe...
static FunctionDecl * CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, DeclContext *DC, QualType &R, TypeSourceInfo *TInfo, StorageClass SC, bool &IsVirtualOkay)
static Scope * getTagInjectionScope(Scope *S, const LangOptions &LangOpts)
Find the Scope in which a tag is implicitly declared if we see an elaborated type specifier in the sp...
static std::pair< diag::kind, SourceLocation > getNoteDiagForInvalidRedeclaration(const T *Old, const T *New)
static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, LookupResult &Previous)
Apply special rules for handling extern "C" declarations.
static bool DeclHasAttr(const Decl *D, const Attr *A)
DeclhasAttr - returns true if decl Declaration already has the target attribute.
static bool AllowOverloadingOfFunction(LookupResult &Previous, ASTContext &Context, const FunctionDecl *New)
Determine whether we allow overloading of the function PrevDecl with another declaration.
static bool isOpenCLSizeDependentType(ASTContext &C, QualType Ty)
static void diagnoseMissingConstinit(Sema &S, const VarDecl *InitDecl, const ConstInitAttr *CIAttr, bool AttrBeforeInit)
static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags, const LookupResult &R)
static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, SourceLocation NameLoc)
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
static bool checkGlobalOrExternCConflict(Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous)
Check for conflict between this global or extern "C" declaration and previous global or extern "C" de...
OpenCLParamType
@ InvalidAddrSpacePtrKernelParam
@ ValidKernelParam
@ InvalidKernelParam
@ RecordKernelParam
@ PtrKernelParam
@ PtrPtrKernelParam
static bool AttrCompatibleWithMultiVersion(attr::Kind Kind, MultiVersionKind MVType)
static const CXXRecordDecl * findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC)
Find the parent class with dependent bases of the innermost enclosing method context.
Definition SemaDecl.cpp:546
static bool shouldConsiderLinkage(const VarDecl *VD)
static bool diagnoseOpenCLTypes(Scope *S, Sema &Se, Declarator &D, DeclContext *DC, QualType R)
Returns true if there hasn't been any invalid type diagnosed.
static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record)
static bool checkNonMultiVersionCompatAttributes(Sema &S, const FunctionDecl *FD, const FunctionDecl *CausedFD, MultiVersionKind MVType)
static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD, const FunctionDecl *NewFD, bool CausesMV, MultiVersionKind MVType)
static DeclContext * getTagInjectionContext(DeclContext *DC)
Find the DeclContext in which a tag is implicitly declared if we see an elaborated type specifier in ...
static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New)
static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for redeclaration diagnostic message.
static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl *Old)
static bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S, DeclContext *Owner, DeclarationName Name, SourceLocation NameLoc, bool IsUnion)
We are trying to inject an anonymous member into the given scope; check if there's an existing declar...
static NamedDecl * DiagnoseInvalidRedeclaration(Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S)
Generate diagnostics for an invalid function redeclaration.
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, DeclarationName Name)
NeedsRebuildingInCurrentInstantiation - Checks whether the given declarator needs to be rebuilt in th...
static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc)
Definition SemaDecl.cpp:788
static bool hasParsedAttr(Scope *S, const Declarator &PD, ParsedAttr::Kind Kind)
static bool CheckMultiVersionFirstFunction(Sema &S, FunctionDecl *FD, MultiVersionKind MVType, const TargetAttr *TA)
Check the validity of a multiversion function declaration that is the first of its kind.
ShadowedDeclKind
Enum describing the select options in diag::warn_decl_shadow.
@ SDK_Field
@ SDK_Global
@ SDK_Local
@ SDK_Typedef
@ SDK_StaticMember
@ SDK_Using
static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S)
static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner, RecordDecl *AnonRecord, AccessSpecifier AS, SmallVectorImpl< NamedDecl * > &Chaining)
InjectAnonymousStructOrUnionMembers - Inject the members of the anonymous struct or union AnonRecord ...
static bool canRedefineFunction(const FunctionDecl *FD, const LangOptions &LangOpts)
canRedefineFunction - checks if a function can be redefined.
static ObjCIvarDecl::AccessControl TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility)
TranslateIvarVisibility - Translate visibility from a token ID to an AST enum value.
static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T)
static OpenCLParamType getOpenCLKernelParameterType(Sema &S, QualType PT)
static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, SourceLocation DefaultInitLoc)
static void RemoveUsingDecls(LookupResult &R)
Removes using shadow declarations from the lookup results.
static bool hasDependentAlignment(VarDecl *VD)
Determines if a variable's alignment is dependent.
static void filterNonConflictingPreviousTypedefDecls(Sema &S, TypedefNameDecl *Decl, LookupResult &Previous)
Typedef declarations don't have linkage, but they still denote the same entity if their types are the...
static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious, LookupResult &Previous)
Check the validity of a mulitversion function declaration.
static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator, Sema &S)
static const NamedDecl * getDefinition(const Decl *D)
static bool isUsingDecl(NamedDecl *D)
static QualType TryToFixInvalidVariablyModifiedType(QualType T, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
static bool hasDeducedAuto(DeclaratorDecl *DD)
static QualType getCoreType(QualType Ty)
static bool isMainFileLoc(const Sema &S, SourceLocation Loc)
static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD)
Check the target attribute of the function for MultiVersion validity.
static void CheckPoppedLabel(LabelDecl *L, Sema &S)
static bool isOutOfScopePreviousDeclaration(NamedDecl *, DeclContext *, ASTContext &)
Determines whether the given declaration is an out-of-scope previous declaration.
static StorageClass StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS)
StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to a VarDecl::StorageClass.
static bool CheckMultiVersionAdditionalDecl(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, MultiVersionKind NewMVType, const TargetAttr *NewTA, const CPUDispatchAttr *NewCPUDisp, const CPUSpecificAttr *NewCPUSpec, bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious, LookupResult &Previous)
Check the validity of a new function declaration being added to an existing multiversioned declaratio...
static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS, QualType T, SourceLocation NameLoc)
Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
Definition SemaDecl.cpp:838
static SourceLocation getCaptureLocation(const LambdaScopeInfo *LSI, const VarDecl *VD)
Return the location of the capture if the given lambda captures the given variable VD,...
static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization, bool IsDefinition)
static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D)
static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum)
static QualType getNextLargerIntegralType(ASTContext &Context, QualType T)
static bool isIncompleteDeclExternC(Sema &S, const T *D)
Determine whether a variable is extern "C" prior to attaching an initializer.
static bool isAttributeTargetADefinition(Decl *D)
static Attr * getImplicitCodeSegAttrFromClass(Sema &S, const FunctionDecl *FD)
Return a CodeSegAttr from a containing class.
static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D)
Check for this common pattern:
static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC, DeclContext *NewDC)
Determine whether a tag originally declared in context OldDC can be redeclared with an unqualified na...
static bool isRecordType(QualType T)
Defines the SourceManager interface.
const NestedNameSpecifier * Specifier
std::string Label
RAII object that pops an ExpressionEvaluationContext when exiting a function body.
ExitFunctionBodyRAII(Sema &S, bool IsLambda)
llvm::APInt getValue() const
Definition Expr.h:1468
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
Definition ASTConsumer.h:72
virtual void HandleInlineFunctionDefinition(FunctionDecl *D)
This callback is invoked each time an inline (method or friend) function definition in a class is com...
Definition ASTConsumer.h:57
virtual bool shouldSkipFunctionBody(Decl *D)
This callback is called for each function if the Parser was initialized with SkipFunctionBodies set t...
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:187
SourceManager & getSourceManager()
Definition ASTContext.h:639
TranslationUnitDecl * getTranslationUnitDecl() const
Definition ASTContext.h:965
QualType getParenType(QualType NamedType) const
CanQualType LongTy
Definition ASTContext.h:981
unsigned getIntWidth(QualType T) const
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
ExternCContextDecl * getExternCContextDecl() const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U)
Determine whether two function types are the same, ignoring exception specifications in cases where t...
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
Definition ASTContext.h:607
QualType getObjCClassType() const
Represents the Objective-C Class type.
QualType getRecordType(const RecordDecl *Decl) const
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateDecl *Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
void setObjCIdRedefinitionType(QualType RedefType)
Set the user-written type that redefines id.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
void setObjCSelRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
CanQualType DependentTy
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
IdentifierTable & Idents
Definition ASTContext.h:604
Builtin::Context & BuiltinInfo
Definition ASTContext.h:606
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
const LangOptions & getLangOpts() const
Definition ASTContext.h:684
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false)
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
void attachCommentsToJustParsedDecls(ArrayRef< Decl * > Decls, const Preprocessor *PP)
Searches existing comments for doc comments that should be attached to Decls.
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
CanQualType UnsignedLongTy
Definition ASTContext.h:982
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType CharTy
Definition ASTContext.h:974
CanQualType IntTy
Definition ASTContext.h:981
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType)
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
CanQualType SignedCharTy
Definition ASTContext.h:981
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
void setNonKeyFunction(const CXXMethodDecl *method)
Observe that the given method cannot be a key function.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
const clang::PrintingPolicy & getPrintingPolicy() const
Definition ASTContext.h:631
QualType getObjCIdType() const
Represents the Objective-CC id type.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
void setManglingNumber(const NamedDecl *ND, unsigned Number)
CanQualType VoidTy
Definition ASTContext.h:972
CanQualType UnsignedCharTy
Definition ASTContext.h:982
CanQualType UnsignedIntTy
Definition ASTContext.h:982
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
CanQualType UnknownAnyTy
CanQualType UnsignedLongLongTy
Definition ASTContext.h:983
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
CanQualType UnsignedShortTy
Definition ASTContext.h:982
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
void setcudaConfigureCallDecl(FunctionDecl *FD)
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
const VariableArrayType * getAsVariableArrayType(QualType T) const
CanQualType ShortTy
Definition ASTContext.h:981
void setObjCClassRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
void ResetObjCLayout(const ObjCContainerDecl *CD)
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
const TargetInfo & getTargetInfo() const
Definition ASTContext.h:667
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
CanQualType LongLongTy
Definition ASTContext.h:981
QualType mergeObjCGCQualifiers(QualType, QualType)
mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 'RHS' attributes and ret...
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
bool hasSameFunctionTypeIgnoringPtrSizes(QualType T, QualType U)
Determine whether two function types are the same, ignoring pointer sizes in the return type and para...
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
@ GE_None
No error.
@ GE_Missing_stdio
Missing a type from <stdio.h>
@ GE_Missing_type
Missing a type.
@ GE_Missing_ucontext
Missing a type from <ucontext.h>
@ GE_Missing_setjmp
Missing a type from <setjmp.h>
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc.
Definition Ownership.h:152
bool isInvalid() const
Definition Ownership.h:165
bool isUsable() const
Definition Ownership.h:166
PtrTy get() const
Definition Ownership.h:169
bool isUnset() const
Definition Ownership.h:167
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Definition Type.h:2653
AlignedAttr * clone(ASTContext &C) const
bool isAlignas() const
Definition Attr.h:704
unsigned getAlignment(ASTContext &Ctx) const
static AllocAlignAttr * CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static AllocSizeAttr * CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, const AttributeCommonInfo &CommonInfo={SourceRange{}})
llvm::StringRef getAnnotation() const
Definition Attr.h:924
Wrapper for source info for arrays.
Definition TypeLoc.h:1487
SourceLocation getLBracketLoc() const
Definition TypeLoc.h:1489
Expr * getSizeExpr() const
Definition TypeLoc.h:1509
TypeLoc getElementLoc() const
Definition TypeLoc.h:1517
SourceLocation getRBracketLoc() const
Definition TypeLoc.h:1497
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition Type.h:2867
QualType getElementType() const
Definition Type.h:2888
static AsmLabelAttr * Create(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, const AttributeCommonInfo &CommonInfo)
static AsmLabelAttr * CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, const AttributeCommonInfo &CommonInfo={SourceRange{}})
Attr - This represents one attribute.
Definition Attr.h:46
attr::Kind getKind() const
Definition Attr.h:86
bool isInherited() const
Definition Attr.h:95
bool isImplicit() const
Returns true if the attribute has been implicitly created instead of explicitly written by the user.
Definition Attr.h:99
Attr * clone(ASTContext &C) const
void setImplicit(bool I)
Definition Attr.h:100
SourceLocation getLocation() const
Definition Attr.h:93
@ AS_Keyword
__ptr16, alignas(...), etc.
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
Definition ParsedAttr.h:636
AttributeFactory & getFactory() const
Definition ParsedAttr.h:724
Type source information for an attributed type.
Definition TypeLoc.h:854
const T * getAttrAs()
Definition TypeLoc.h:880
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
Definition TypeLoc.h:868
An attributed type is a type to which a type attribute has been applied.
Definition Type.h:4660
QualType getModifiedType() const
Definition Type.h:4682
bool isCallingConv() const
Definition Type.cpp:3542
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Definition Type.h:4713
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition Type.h:4972
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition Expr.h:4127
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Definition Expr.h:4181
Expr * getCond() const
getCond - Return the condition expression; this is defined in terms of the opaque value.
Definition Expr.h:4169
A builtin binary operation expression such as "x + y" or "x <= y".
Definition Expr.h:3727
Expr * getLHS() const
Definition Expr.h:3776
Expr * getRHS() const
Definition Expr.h:3778
static bool isCompoundAssignmentOp(Opcode Opc)
Definition Expr.h:3867
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition Decl.h:4100
bool doesNotEscape() const
Definition Decl.h:4251
static BuiltinAttr * CreateImplicit(ASTContext &Ctx, unsigned ID, const AttributeCommonInfo &CommonInfo={SourceRange{}})
This class is used for builtin types like 'int'.
Definition Type.h:2480
Holds information about both target-independent and target-specific builtins, allowing easy queries b...
Definition Builtins.h:65
bool performsCallback(unsigned ID, llvm::SmallVectorImpl< int > &Encoding) const
Determine whether this builtin has callback behavior (see llvm::AbstractCallSites for details).
Definition Builtins.cpp:161
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
Definition Builtins.h:222
const char * getHeaderName(unsigned ID) const
If this is a library function that comes from a specific header, retrieve that header name.
Definition Builtins.h:187
bool isReturnsTwice(unsigned ID) const
Return true if we know this builtin can return twice.
Definition Builtins.h:119
bool allowTypeMismatch(unsigned ID) const
Determines whether a declaration of this builtin should be recognized even if the type doesn't match ...
Definition Builtins.h:163
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
Definition Builtins.h:93
void forgetBuiltin(unsigned ID, IdentifierTable &Table)
Completely forget that the given ID was ever considered a builtin, e.g., because the user provided a ...
Definition Builtins.cpp:108
bool isHeaderDependentFunction(unsigned ID) const
Returns true if this builtin requires appropriate header in other compilers.
Definition Builtins.h:145
bool isScanfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like scanf in its formatting rules and, if so, set the index to the...
Definition Builtins.cpp:156
bool isConstWithoutErrno(unsigned ID) const
Return true if this function has no side effects and doesn't read memory, except for possibly errno.
Definition Builtins.h:211
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc",...
Definition Builtins.h:138
bool isPrintfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like printf in its formatting rules and, if so, set the index to th...
Definition Builtins.cpp:151
const char * getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
Definition Builtins.h:83
bool isPredefinedRuntimeFunction(unsigned ID) const
Determines whether this builtin is a predefined compiler-rt/libgcc function, such as "__clear_cache",...
Definition Builtins.h:152
bool isPure(unsigned ID) const
Return true if this function has no side effects.
Definition Builtins.h:98
bool isNoThrow(unsigned ID) const
Return true if we know this builtin never throws an exception.
Definition Builtins.h:109
bool isConst(unsigned ID) const
Return true if this function has no side effects and doesn't read memory.
Definition Builtins.h:104
static C11NoReturnAttr * Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo)
cpus_iterator cpus_begin() const
Definition Attr.h:2060
unsigned cpus_size() const
Definition Attr.h:2062
unsigned cpus_size() const
Definition Attr.h:2105
cpus_iterator cpus_end() const
Definition Attr.h:2104
llvm::iterator_range< cpus_iterator > cpus() const
Definition Attr.h:2106
cpus_iterator cpus_begin() const
Definition Attr.h:2103
static CUDADeviceAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static CUDAHostAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Represents a base class of a C++ class.
Definition DeclCXX.h:146
SourceLocation getBeginLoc() const LLVM_READONLY
Definition DeclCXX.h:190
SourceLocation getEndLoc() const LLVM_READONLY
Definition DeclCXX.h:191
Represents a call to a C++ constructor.
Definition ExprCXX.h:1460
bool isElidable() const
Whether this construction is elidable.
Definition ExprCXX.h:1538
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition ExprCXX.h:1611
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition ExprCXX.h:1532
Represents a C++ constructor within a class.
Definition DeclCXX.h:2393
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
Definition DeclCXX.cpp:2661
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Definition DeclCXX.cpp:2621
Represents a C++ conversion function within a class.
Definition DeclCXX.h:2720
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Definition DeclCXX.cpp:2790
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation)
Definition DeclCXX.cpp:2076
Represents a C++ destructor within a class.
Definition DeclCXX.h:2656
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
Definition DeclCXX.cpp:2756
A mapping from each virtual member function to its set of final overriders.
Represents a static or instance method of a struct/union/class.
Definition DeclCXX.h:1937
void addOverriddenMethod(const CXXMethodDecl *MD)
Definition DeclCXX.cpp:2418
bool isVirtual() const
Definition DeclCXX.h:1982
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition DeclCXX.h:2053
Qualifiers getMethodQualifiers() const
Definition DeclCXX.h:2083
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Definition DeclCXX.cpp:2193
bool isConst() const
Definition DeclCXX.h:1979
bool isStatic() const
Definition DeclCXX.cpp:2103
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Definition DeclCXX.cpp:2376
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition DeclCXX.h:2023
A call to an overloaded operator written using operator syntax.
Definition ExprCXX.h:82
Represents a C++ struct/union/class.
Definition DeclCXX.h:254
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class....
Definition DeclCXX.h:1278
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
Definition DeclCXX.h:1184
base_class_iterator bases_end()
Definition DeclCXX.h:597
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition DeclCXX.h:1310
base_class_range bases()
Definition DeclCXX.h:588
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
Definition DeclCXX.h:1320
CXXRecordDecl * getDefinition() const
Definition DeclCXX.h:534
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition DeclCXX.h:582
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
Definition DeclCXX.cpp:131
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
base_class_iterator bases_begin()
Definition DeclCXX.h:595
capture_const_range captures() const
Definition DeclCXX.h:1058
bool hasDefinition() const
Definition DeclCXX.h:541
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition DeclCXX.cpp:1800
LambdaCaptureDefault getLambdaCaptureDefault() const
Definition DeclCXX.h:1032
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition DeclCXX.cpp:1804
bool hasNonTrivialCopyConstructor() const
Determine whether this class has a non-trivial copy constructor (C++ [class.copy]p6,...
Definition DeclCXX.h:1232
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition DeclCXX.h:493
Represents a C++ nested-name-specifier or a global scope specifier.
Definition DeclSpec.h:64
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition DeclSpec.h:192
char * location_data() const
Retrieve the data associated with the source-location information.
Definition DeclSpec.h:218
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition DeclSpec.h:197
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition DeclSpec.cpp:125
SourceRange getRange() const
Definition DeclSpec.h:69
SourceLocation getBeginLoc() const
Definition DeclSpec.h:73
bool isSet() const
Deprecated.
Definition DeclSpec.h:210
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
Definition DeclSpec.cpp:151
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition DeclSpec.h:77
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition DeclSpec.h:195
bool isEmpty() const
No scope specifier.
Definition DeclSpec.h:190
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition DeclSpec.cpp:131
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition Expr.h:2730
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition Expr.h:2921
Expr * getCallee()
Definition Expr.h:2880
arg_range arguments()
Definition Expr.h:2958
bool isCallToStdMove() const
Definition Expr.h:3049
static CallbackAttr * CreateImplicit(ASTContext &Ctx, int *Encoding, unsigned EncodingSize, const AttributeCommonInfo &CommonInfo={SourceRange{}})
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CastKind getCastKind() const
Definition Expr.h:3442
Expr * getSubExpr()
Definition Expr.h:3448
static CharSourceRange getCharRange(SourceRange R)
CharUnits - This is an opaque type for sizes expressed in character units.
Definition CharUnits.h:38
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition CharUnits.h:116
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition CharUnits.h:179
Declaration of a function specialization at template class scope.
static ClassScopeFunctionSpecializationDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, CXXMethodDecl *FD, bool HasExplicitTemplateArgs, const TemplateArgumentListInfo &TemplateArgs)
Declaration of a class template.
ConditionalOperator - The ?: ternary operator.
Definition Expr.h:4065
static ConstAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
bool isConstinit() const
Definition Attr.h:2849
static ConstInitAttr * Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo)
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
Definition Type.cpp:141
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
Definition Type.cpp:176
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
DLLExportAttr * clone(ASTContext &C) const
static DLLExportAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static DLLImportAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
The results of name lookup within a DeclContext.
Definition DeclBase.h:1227
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition DeclBase.h:2084
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition DeclBase.h:1302
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition DeclBase.h:1815
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
Definition DeclBase.h:1939
bool isFileContext() const
Definition DeclBase.h:1885
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isObjCContainer() const
Definition DeclBase.h:1854
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition DeclBase.h:1831
bool isNamespace() const
Definition DeclBase.h:1899
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
bool isTranslationUnit() const
Definition DeclBase.h:1890
bool isRecord() const
Definition DeclBase.h:1894
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void removeDecl(Decl *D)
Removes a declaration from this context.
void addDecl(Decl *D)
Add the declaration D into this context.
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition DeclBase.h:2064
bool isFunctionOrMethod() const
Definition DeclBase.h:1867
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Decl::Kind getDeclKind() const
Definition DeclBase.h:1808
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
Definition DeclGroup.h:68
A reference to a declared variable, function, enum, etc.
Definition Expr.h:1217
SourceLocation getBeginLoc() const LLVM_READONLY
Definition Expr.cpp:495
ValueDecl * getDecl()
Definition Expr.h:1285
Captures information about "declaration specifiers".
Definition DeclSpec.h:229
bool isVirtualSpecified() const
Definition DeclSpec.h:578
bool isModulePrivateSpecified() const
Definition DeclSpec.h:751
bool hasAutoTypeSpec() const
Definition DeclSpec.h:526
static const TST TST_typename
Definition DeclSpec.h:287
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error.
Definition DeclSpec.cpp:616
void ClearStorageClassSpecs()
Definition DeclSpec.h:454
static const TST TST_underlyingType
Definition DeclSpec.h:292
bool isNoreturnSpecified() const
Definition DeclSpec.h:591
TST getTypeSpecType() const
Definition DeclSpec.h:476
SourceLocation getStorageClassSpecLoc() const
Definition DeclSpec.h:449
SCS getStorageClassSpec() const
Definition DeclSpec.h:440
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition DeclSpec.cpp:822
SourceLocation getBeginLoc() const LLVM_READONLY
Definition DeclSpec.h:507
SourceRange getSourceRange() const LLVM_READONLY
Definition DeclSpec.h:506
void SetRangeEnd(SourceLocation Loc)
Definition DeclSpec.h:639
static const TST TST_interface
Definition DeclSpec.h:285
static const TST TST_typeofExpr
Definition DeclSpec.h:289
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition DeclSpec.h:547
void SetRangeStart(SourceLocation Loc)
Definition DeclSpec.h:638
SourceLocation getNoreturnSpecLoc() const
Definition DeclSpec.h:592
bool isExternInLinkageSpec() const
Definition DeclSpec.h:444
static const TST TST_union
Definition DeclSpec.h:283
SCS
storage-class-specifier
Definition DeclSpec.h:233
SourceLocation getExplicitSpecLoc() const
Definition DeclSpec.h:584
static const TST TST_int
Definition DeclSpec.h:267
SourceLocation getModulePrivateSpecLoc() const
Definition DeclSpec.h:752
bool isMissingDeclaratorOk()
Checks if this DeclSpec can stand alone, without a Declarator.
ParsedType getRepAsType() const
Definition DeclSpec.h:486
void UpdateTypeRep(ParsedType Rep)
Definition DeclSpec.h:715
TSCS getThreadStorageClassSpec() const
Definition DeclSpec.h:441
ParsedAttributes & getAttributes()
Definition DeclSpec.h:795
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
Definition DeclSpec.h:556
SourceLocation getConstSpecLoc() const
Definition DeclSpec.h:548
SourceRange getExplicitSpecRange() const
Definition DeclSpec.h:585
Expr * getRepAsExpr() const
Definition DeclSpec.h:494
static const TST TST_enum
Definition DeclSpec.h:282
static const TST TST_decltype
Definition DeclSpec.h:290
static bool isDeclRep(TST T)
Definition DeclSpec.h:415
bool isInlineSpecified() const
Definition DeclSpec.h:567
SourceLocation getRestrictSpecLoc() const
Definition DeclSpec.h:549
static const TST TST_class
Definition DeclSpec.h:286
void ClearConstexprSpec()
Definition DeclSpec.h:763
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
Definition DeclSpec.cpp:541
static const TST TST_atomic
Definition DeclSpec.h:296
SourceLocation getThreadStorageClassSpecLoc() const
Definition DeclSpec.h:450
Decl * getRepAsDecl() const
Definition DeclSpec.h:490
bool isFriendSpecified() const
Definition DeclSpec.h:748
static const TST TST_unspecified
Definition DeclSpec.h:260
SourceLocation getAtomicSpecLoc() const
Definition DeclSpec.h:551
SourceLocation getVirtualSpecLoc() const
Definition DeclSpec.h:579
SourceLocation getConstexprSpecLoc() const
Definition DeclSpec.h:758
CXXScopeSpec & getTypeSpecScope()
Definition DeclSpec.h:503
SourceLocation getTypeSpecTypeLoc() const
Definition DeclSpec.h:514
void UpdateExprRep(Expr *Rep)
Definition DeclSpec.h:719
static const TSCS TSCS_thread_local
Definition DeclSpec.h:249
static const TST TST_error
Definition DeclSpec.h:300
ExplicitSpecifier getExplicitSpecifier() const
Definition DeclSpec.h:574
bool isTypeSpecOwned() const
Definition DeclSpec.h:480
SourceLocation getInlineSpecLoc() const
Definition DeclSpec.h:570
SourceLocation getUnalignedSpecLoc() const
Definition DeclSpec.h:552
SourceLocation getVolatileSpecLoc() const
Definition DeclSpec.h:550
bool hasExplicitSpecifier() const
Definition DeclSpec.h:581
bool hasConstexprSpecifier() const
Definition DeclSpec.h:759
static const TST TST_typeofType
Definition DeclSpec.h:288
static const TST TST_auto
Definition DeclSpec.h:293
ConstexprSpecKind getConstexprSpecifier() const
Definition DeclSpec.h:754
static const TST TST_struct
Definition DeclSpec.h:284
Decl - This represents one declaration (or definition), e.g.
Definition DeclBase.h:89
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Definition DeclBase.h:984
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
Definition DeclBase.h:999
SourceLocation getEndLoc() const LLVM_READONLY
Definition DeclBase.h:426
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
Definition DeclBase.h:1143
bool isFunctionOrFunctionTemplate() const
Whether this declaration is a function or function template.
Definition DeclBase.h:1042
T * getAttr() const
Definition DeclBase.h:543
bool hasAttrs() const
Definition DeclBase.h:489
void addAttr(Attr *A)
Definition DeclBase.cpp:881
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition DeclBase.h:563
void setAttrs(const AttrVec &Attrs)
Definition DeclBase.h:491
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
Definition DeclBase.h:694
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration.
Definition DeclBase.h:1074
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition Decl.cpp:99
Module * getOwningModuleForLinkage(bool IgnoreLinkage=false) const
Get the module that owns this declaration for linkage purposes.
Definition Decl.cpp:1496
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition DeclBase.h:1092
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition DeclBase.cpp:132
void setTopLevelDeclInObjCContainer(bool V=true)
Definition DeclBase.h:602
const DeclContext * getParentFunctionOrMethod() const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...
Definition DeclBase.cpp:286
bool isInIdentifierNamespace(unsigned NS) const
Definition DeclBase.h:818
@ FOK_Undeclared
A friend of a previously-undeclared entity.
Definition DeclBase.h:1136
@ FOK_None
Not a friend object.
Definition DeclBase.h:1134
@ FOK_Declared
A friend of a previously-declared entity.
Definition DeclBase.h:1135
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition DeclBase.cpp:468
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition DeclBase.h:773
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition DeclBase.cpp:218
void dropAttrs()
Definition DeclBase.cpp:874
@ OBJC_TQ_CSNullability
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
Definition DeclBase.h:213
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
Definition DeclBase.h:1103
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition DeclBase.h:2489
bool isInvalidDecl() const
Definition DeclBase.h:558
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition DeclBase.h:529
void setAccess(AccessSpecifier AS)
Definition DeclBase.h:473
SourceLocation getLocation() const
Definition DeclBase.h:430
@ IDNS_Ordinary
Ordinary names.
Definition DeclBase.h:147
void setLocalOwningModule(Module *M)
Definition DeclBase.h:760
void setImplicit(bool I=true)
Definition DeclBase.h:564
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
Definition DeclBase.h:578
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
Definition DeclBase.cpp:443
DeclContext * getDeclContext()
Definition DeclBase.h:439
attr_range attrs() const
Definition DeclBase.h:506
AccessSpecifier getAccess() const
Definition DeclBase.h:478
SourceLocation getBeginLoc() const LLVM_READONLY
Definition DeclBase.h:422
void dropAttr()
Definition DeclBase.h:518
AttrVec & getAttrs()
Definition DeclBase.h:495
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Definition DeclBase.cpp:327
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition DeclBase.h:843
bool hasAttr() const
Definition DeclBase.h:547
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
Definition DeclBase.h:1152
void setLexicalDeclContext(DeclContext *DC)
Definition DeclBase.cpp:331
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition DeclBase.h:901
Kind getKind() const
Definition DeclBase.h:433
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
Get the name of the literal operator function with II as the identifier.
DeclarationName getCXXConversionFunctionName(CanQualType Ty)
Returns the name of a C++ conversion function for the given Type.
DeclarationName getCXXDestructorName(CanQualType Ty)
Returns the name of a C++ destructor for the given Type.
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
DeclarationName getCXXDeductionGuideName(TemplateDecl *TD)
Returns the name of a C++ deduction guide for the given template.
DeclarationName getCXXConstructorName(CanQualType Ty)
Returns the name of a C++ constructor for the given Type.
The name of a declaration.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
Represents a ValueDecl that came out of a declarator.
Definition Decl.h:686
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
Definition Decl.h:744
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
Definition Decl.h:729
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations.
Definition Decl.cpp:1891
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition Decl.cpp:1931
SourceLocation getTypeSpecStartLoc() const
Definition Decl.cpp:1829
SourceLocation getBeginLoc() const LLVM_READONLY
Definition Decl.h:738
unsigned getNumTemplateParameterLists() const
Definition Decl.h:774
void setTypeSourceInfo(TypeSourceInfo *TI)
Definition Decl.h:721
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition Decl.cpp:1841
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
Definition Decl.h:762
TypeSourceInfo * getTypeSourceInfo() const
Definition Decl.h:715
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Definition Decl.cpp:1875
Information about one declarator, including the parsed type information and the identifier.
Definition DeclSpec.h:1803
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
Definition DeclSpec.h:2298
void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
Definition DeclSpec.h:2197
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition DeclSpec.h:2240
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition DeclSpec.h:1910
Expr * getAsmLabel() const
Definition DeclSpec.h:2545
FunctionDefinitionKind getFunctionDefinitionKind() const
Definition DeclSpec.h:2580
const ParsedAttributes & getAttributes() const
Definition DeclSpec.h:2523
void setRedeclaration(bool Val)
Definition DeclSpec.h:2601
SourceLocation getIdentifierLoc() const
Definition DeclSpec.h:2194
SourceLocation getEndLoc() const LLVM_READONLY
Definition DeclSpec.h:1947
Expr * getTrailingRequiresClause()
Sets a trailing requires clause for this declarator.
Definition DeclSpec.h:2473
void setInvalidType(bool Val=true)
Definition DeclSpec.h:2556
TemplateParameterList * getInventedTemplateParameterList() const
The template parameter list generated from the explicit template parameters along with any invented t...
Definition DeclSpec.h:2503
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition DeclSpec.h:2236
bool isRedeclaration() const
Definition DeclSpec.h:2602
const DecompositionDeclarator & getDecompositionDeclarator() const
Definition DeclSpec.h:1931
SourceLocation getBeginLoc() const LLVM_READONLY
Definition DeclSpec.h:1946
bool isCtorOrDtor()
Returns true if this declares a constructor or a destructor.
Definition DeclSpec.cpp:419
bool isFunctionDefinition() const
Definition DeclSpec.h:2576
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition DeclSpec.h:1929
bool hasInitializer() const
Definition DeclSpec.h:2585
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
Definition DeclSpec.h:2572
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition DeclSpec.h:1925
void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc)
takeAttributes - Takes attributes from the given parsed-attributes set and add them to this declarato...
Definition DeclSpec.h:2516
IdentifierInfo * getIdentifier() const
Definition DeclSpec.h:2188
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
Definition DeclSpec.h:2211
bool isInvalidType() const
Definition DeclSpec.h:2557
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition DeclSpec.h:1945
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
Definition DeclSpec.h:2184
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
Definition DeclSpec.h:2588
bool isStaticMember()
Returns true if this declares a static member.
Definition DeclSpec.cpp:411
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition DeclSpec.h:1917
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition DeclSpec.h:2329
A decomposition declaration.
Definition DeclCXX.h:3877
static DecompositionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation LSquareLoc, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< BindingDecl * > Bindings)
Definition DeclCXX.cpp:3202
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
Definition DeclSpec.h:1702
SourceRange getSourceRange() const
Definition DeclSpec.h:1747
SourceLocation getLSquareLoc() const
Definition DeclSpec.h:1745
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition Type.h:4938
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it's either not been deduced or was deduce...
Definition Type.h:4957
bool isDeduced() const
Definition Type.h:4960
void setNameLoc(SourceLocation Loc)
Definition TypeLoc.h:2287
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition TypeLoc.h:2267
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition TypeLoc.h:2276
Concrete class used by the front-end to report problems and issues.
Definition Diagnostic.h:191
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition Diagnostic.h:867
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition Diagnostic.h:882
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition TypeLoc.h:2208
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition TypeLoc.h:2217
An instance of this object exists for each enum constant that is defined.
Definition Decl.h:2997
static EnumConstantDecl * Create(ASTContext &C, EnumDecl *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
Definition Decl.cpp:4871
const Expr * getInitExpr() const
Definition Decl.h:3016
const llvm::APSInt & getInitVal() const
Definition Decl.h:3018
Represents an enum.
Definition Decl.h:3537
enumerator_range enumerators() const
Definition Decl.h:3666
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition Decl.h:3733
void setIntegerType(QualType T)
Set the underlying integer type.
Definition Decl.h:3702
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
Definition Decl.h:3705
bool isComplete() const
Returns true if this can be considered a complete type.
Definition Decl.h:3747
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
Definition Decl.cpp:4356
bool isClosedFlag() const
Returns true if this enum is annotated with flag_enum and isn't annotated with enum_extensibility(ope...
Definition Decl.cpp:4401
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition Decl.h:3742
SourceRange getIntegerTypeRange() const LLVM_READONLY
Retrieve the source range that covers the underlying type if specified.
Definition Decl.cpp:4376
void setPromotionType(QualType T)
Set the promotion type.
Definition Decl.h:3688
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition Decl.h:3693
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Definition Type.h:4631
EvaluatedExprVisitor - This class visits 'Expr *'s.
Store information needed for an explicit specifier.
Definition DeclCXX.h:1793
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition ExprCXX.h:3346
This represents one expression.
Definition Expr.h:109
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition Expr.h:168
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Definition Expr.h:185
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition Expr.cpp:2775
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Definition Expr.h:238
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition Expr.cpp:2771
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
Definition Expr.cpp:2755
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant,...
Definition Expr.cpp:3003
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition Expr.cpp:228
Optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
QualType getType() const
Definition Expr.h:141
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
Definition Decl.h:2782
bool isBitField() const
Determines whether this field is a bitfield.
Definition Decl.h:2860
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
Definition Decl.cpp:4125
bool isZeroLengthBitField(const ASTContext &Ctx) const
Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...
Definition Decl.cpp:4140
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Definition Decl.h:2974
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition Decl.cpp:4110
static FileScopeAsmDecl * Create(ASTContext &C, DeclContext *DC, StringLiteral *Str, SourceLocation AsmLoc, SourceLocation RParenLoc)
Definition Decl.cpp:5000
static FinalAttr * Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo)
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition Diagnostic.h:70
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Definition Diagnostic.h:133
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition Diagnostic.h:122
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition Diagnostic.h:96
static FormatArgAttr * CreateImplicit(ASTContext &Ctx, ParamIdx FormatIdx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static FormatAttr * CreateImplicit(ASTContext &Ctx, IdentifierInfo *Type, int FormatIdx, int FirstArg, const AttributeCommonInfo &CommonInfo={SourceRange{}})
Represents a function declaration or definition.
Definition Decl.h:1813
bool isMultiVersion() const
True if this function is considered a multiversioned function.
Definition Decl.h:2390
const ParmVarDecl * getParamDecl(unsigned i) const
Definition Decl.h:2461
bool isPure() const
Whether this virtual function is pure, i.e.
Definition Decl.h:2145
ConstexprSpecKind getConstexprKind() const
Definition Decl.h:2244
void setPreviousDeclaration(FunctionDecl *PrevDecl)
Definition Decl.cpp:3232
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
Definition Decl.cpp:3654
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition Decl.cpp:3650
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition Decl.h:2106
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
Definition Decl.h:1983
void setHasSkippedBody(bool Skipped=true)
Definition Decl.h:2381
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
Definition Decl.cpp:3486
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
Definition Decl.cpp:3261
param_iterator param_end()
Definition Decl.h:2451
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition Decl.h:2560
void setIsMultiVersion(bool V=true)
Sets the multiversion state for this declaration and all of its redeclarations.
Definition Decl.h:2396
QualType getReturnType() const
Definition Decl.h:2492
ArrayRef< ParmVarDecl * > parameters() const
Definition Decl.h:2438
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
Definition Decl.h:2174
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition Decl.h:2162
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
Definition Decl.cpp:3159
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition Decl.cpp:3751
bool hasWrittenPrototype() const
Whether this function has a written prototype.
Definition Decl.h:2216
void setWillHaveBody(bool V=true)
Definition Decl.h:2387
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
Definition Decl.h:2211
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition Decl.cpp:3761
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition Decl.cpp:3246
param_iterator param_begin()
Definition Decl.h:2450
bool isVariadic() const
Whether this function is variadic.
Definition Decl.cpp:2866
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition Decl.h:2118
bool isDeleted() const
Whether this function has been deleted.
Definition Decl.h:2293
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
Definition Decl.cpp:3018
void setPure(bool P=true)
Definition Decl.cpp:2997
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
Definition Decl.cpp:3695
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition Decl.h:2535
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function.
Definition Decl.cpp:3943
void setTrivial(bool IT)
Definition Decl.h:2163
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition Decl.cpp:3606
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition Decl.h:2238
bool isReplaceableGlobalAllocationFunction(Optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition Decl.cpp:3068
void setHasInheritedPrototype(bool P=true)
State that this function inherited its prototype from a previous declaration.
Definition Decl.h:2233
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition Decl.cpp:3163
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition Decl.h:2149
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
Definition Decl.h:2196
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
Definition Decl.h:2141
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
Definition Decl.h:2380
FunctionDecl * getDefinition()
Get the definition for this declaration.
Definition Decl.h:2074
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
Definition Decl.cpp:3010
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
Definition Decl.h:2555
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
Definition Decl.cpp:2922
void setRangeEnd(SourceLocation E)
Definition Decl.h:2012
bool isDefaulted() const
Whether this function is defaulted.
Definition Decl.h:2170
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition Decl.cpp:3966
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
Definition Decl.h:2572
const IdentifierInfo * getLiteralIdentifier() const
getLiteralIdentifier - The literal suffix identifier this function represents, if any.
Definition Decl.cpp:3600
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Definition Decl.cpp:3592
void setConstexprKind(ConstexprSpecKind CSK)
Definition Decl.h:2241
void setDefaulted(bool D=true)
Definition Decl.h:2171
bool isConsteval() const
Definition Decl.h:2250
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
Definition Decl.h:2509
void setBody(Stmt *B)
Definition Decl.cpp:2990
bool isGlobal() const
Determines whether this is a global function.
Definition Decl.cpp:3177
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition Decl.h:2636
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
Definition Decl.cpp:3622
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition Decl.cpp:3319
DeclarationNameInfo getNameInfo() const
Definition Decl.h:2005
void setDeletedAsWritten(bool D=true)
Definition Decl.h:2301
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition Decl.cpp:2898
void setHasImplicitReturnZero(bool IRZ)
State that falling off this function implicitly returns null/zero.
Definition Decl.h:2203
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Definition Decl.cpp:2945
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition Decl.h:2546
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
Definition Decl.cpp:3209
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Definition Decl.h:2386
Represents a prototype with parameter type info, e.g.
Definition Type.h:3883
unsigned getNumParams() const
Definition Type.h:4087
QualType getParamType(unsigned i) const
Definition Type.h:4089
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition Type.h:4118
bool isVariadic() const
Whether this function prototype is variadic.
Definition Type.h:4209
ExtProtoInfo getExtProtoInfo() const
Definition Type.h:4098
ArrayRef< QualType > getParamTypes() const
Definition Type.h:4094
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
void mergePrevDecl(FunctionTemplateDecl *Prev)
Merge Prev with our RedeclarableTemplateDecl::Common.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Wrapper for source info for functions.
Definition TypeLoc.h:1354
SourceLocation getLParenLoc() const
Definition TypeLoc.h:1386
A class which abstracts out some details necessary for making a call.
Definition Type.h:3649
ExtInfo withCallingConv(CallingConv cc) const
Definition Type.h:3764
CallingConv getCC() const
Definition Type.h:3711
ExtInfo withProducesResult(bool producesResult) const
Definition Type.h:3730
unsigned getRegParm() const
Definition Type.h:3704
bool getNoCallerSavedRegs() const
Definition Type.h:3700
ExtInfo withNoReturn(bool noReturn) const
Definition Type.h:3723
bool getHasRegParm() const
Definition Type.h:3702
bool getNoReturn() const
Definition Type.h:3697
bool getProducesResult() const
Definition Type.h:3698
ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const
Definition Type.h:3744
ExtInfo withRegParm(unsigned RegParm) const
Definition Type.h:3758
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition Type.h:3538
ExtInfo getExtInfo() const
Definition Type.h:3813
static StringRef getNameForCallConv(CallingConv CC)
Definition Type.cpp:3119
unsigned getRegParmType() const
Definition Type.h:3804
CallingConv getCallConv() const
Definition Type.h:3812
QualType getReturnType() const
Definition Type.h:3801
bool getCmseNSCallAttr() const
Definition Type.h:3811
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
bool isEditorPlaceholder() const
Return true if this identifier is an editor placeholder.
StringRef getName() const
Return the actual identifier string.
iterator - Iterate over the decls of a specified declaration name.
iterator begin(DeclarationName Name)
begin - Returns an iterator for decls with the name 'Name'.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
void InsertDeclAfter(iterator Pos, NamedDecl *D)
Insert the given declaration after the given iterator position.
iterator end()
end - Returns an iterator that has 'finished'.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition Expr.h:3545
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Definition Expr.cpp:1856
Represents a C array with an unspecified size.
Definition Type.h:2973
Represents a field injected from an anonymous union/struct into the parent scope.
Definition Decl.h:3037
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
Definition Decl.cpp:4899
void setInherited(bool I)
Definition Attr.h:150
Description of a constructor that was inherited from a base class.
Definition DeclCXX.h:2364
Describes an C or C++ initializer list.
Definition Expr.h:4710
child_range children()
Definition Expr.h:4897
static InitSegAttr * CreateImplicit(ASTContext &Ctx, llvm::StringRef Section, const AttributeCommonInfo &CommonInfo={SourceRange{}})
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Describes an entity that is being initialized.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition Expr.cpp:823
Represents the declaration of a label.
Definition Decl.h:466
bool isResolvedMSAsmLabel() const
Definition Decl.h:501
LabelStmt * getStmt() const
Definition Decl.h:490
bool isMSAsmLabel() const
Definition Decl.h:500
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition LangOptions.h:58
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
clang::ObjCRuntime ObjCRuntime
VersionTuple getOpenCLVersionTuple() const
Return the OpenCL C or C++ version as a VersionTuple.
void push_back(const T &LocalValue)
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
Definition Lexer.cpp:1273
Represents a linkage specification.
Definition DeclCXX.h:2784
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LanguageIDs Lang, bool HasBraces)
Definition DeclCXX.cpp:2819
void InstantiatedLocal(const Decl *D, Decl *Inst)
A class for iterating through a result set and possibly filtering out results.
Definition Lookup.h:617
void erase()
Erase the last element returned from this iterator.
Definition Lookup.h:654
Represents the results of name lookup.
Definition Lookup.h:46
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
Definition Lookup.h:63
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition Lookup.h:68
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition Lookup.h:73
@ NotFound
No entity found met the criteria.
Definition Lookup.h:50
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition Lookup.h:55
@ Found
Name lookup found a single declaration that met the criteria.
Definition Lookup.h:59
DeclClass * getAsSingle() const
Definition Lookup.h:507
bool empty() const
Return true if no decls were found.
Definition Lookup.h:339
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition Lookup.h:606
Filter makeFilter()
Create a filter for this result set.
Definition Lookup.h:682
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition Lookup.h:517
bool isAmbiguous() const
Definition Lookup.h:301
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition Lookup.h:308
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition Lookup.h:253
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
Definition Lookup.h:612
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition Lookup.h:524
LookupResultKind getResultKind() const
Definition Lookup.h:321
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition Lookup.h:583
DeclarationName getLookupName() const
Gets the name to look up.
Definition Lookup.h:243
iterator end() const
Definition Lookup.h:336
@ AmbiguousTagHiding
Name lookup results in an ambiguity because an entity with a tag name was hidden by an entity with an...
Definition Lookup.h:135
iterator begin() const
Definition Lookup.h:335
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition Lookup.h:233
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator)=0
Retrieve the mangling number of a new lambda expression with the given call operator within this cont...
virtual unsigned getStaticLocalNumber(const VarDecl *VD)=0
Static locals are numbered by source order.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition Expr.h:3090
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition Expr.h:3169
Expr * getBase() const
Definition Expr.h:3163
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition Type.h:2815
Describes a module or submodule.
Definition Module.h:96
SourceLocation DefinitionLoc
The location of the module definition.
Definition Module.h:102
Module * Parent
The parent of this module.
Definition Module.h:124
ModuleKind Kind
The kind of this module.
Definition Module.h:120
bool isModulePurview() const
Does this Module scope describe part of the purview of a named C++ module?
Definition Module.h:151
@ PrivateModuleFragment
This is the private module fragment within some C++ module.
Definition Module.h:116
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition Module.cpp:221
@ ClassId_NSObject
Definition NSAPI.h:30
This represents a decl that may have a name.
Definition Decl.h:223
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition Decl.h:429
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition Decl.h:244
bool isLinkageValid() const
True if the computed linkage is valid.
Definition Decl.cpp:1071
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition Decl.h:250
Visibility getVisibility() const
Determines the visibility of this entity.
Definition Decl.h:388
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition Decl.h:368
bool hasLinkageBeenComputed() const
True if something has required us to compute the linkage of this declaration.
Definition Decl.h:423
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition Decl.h:373
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition Decl.h:287
bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer=true) const
Determine whether this declaration, if known to be well-formed within its context,...
Definition Decl.cpp:1709
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
Definition DeclBase.h:626
bool hasLinkage() const
Determine whether this declaration has linkage.
Definition Decl.cpp:1785
bool isExternallyVisible() const
Definition Decl.h:377
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition Decl.h:343
Represent a C++ namespace.
Definition Decl.h:514
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Definition Decl.h:568
Class that aids in the construction of nested-name-specifiers along with source-location information ...
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool containsErrors() const
Whether this nested name specifier contains an error.
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
static NoThrowAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static llvm::Optional< MapTypeTy > isDeclareTargetDeclaration(const ValueDecl *VD)
Definition AttrImpl.cpp:145
static llvm::Optional< DevTypeTy > getDeviceType(const ValueDecl *VD)
Definition AttrImpl.cpp:163
ObjCCategoryDecl - Represents a category declaration.
Definition DeclObjC.h:2266
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition DeclObjC.h:2713
ObjCContainerDecl - Represents a container for method declarations.
Definition DeclObjC.h:947
ObjCIvarDecl * getIvarDecl(IdentifierInfo *Id) const
getIvarDecl - This method looks up an ivar in this ContextDecl.
Definition DeclObjC.cpp:80
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition DeclObjC.h:2538
Represents an ObjC class declaration.
Definition DeclObjC.h:1151
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition DeclObjC.h:1527
known_extensions_range known_extensions() const
Definition DeclObjC.h:1739
ObjCIvarDecl - Represents an ObjC instance variable.
Definition DeclObjC.h:1923
static ObjCIvarDecl * Create(ASTContext &C, ObjCContainerDecl *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW=nullptr, bool synthesized=false)
An expression that sends a message to the given Objective-C object or class.
Definition ExprObjC.h:942
ObjCMethodDecl - Represents an instance or class method declaration.
Definition DeclObjC.h:139
param_const_iterator param_end() const
Definition DeclObjC.h:361
param_const_iterator param_begin() const
Definition DeclObjC.h:357
const ParmVarDecl *const * param_const_iterator
Definition DeclObjC.h:352
ParmVarDecl *const * param_iterator
Definition DeclObjC.h:353
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition ObjCRuntime.h:81
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
Definition ObjCRuntime.h:96
Wrapper for void* pointer.
Definition Ownership.h:50
PtrTy get() const
Definition Ownership.h:80
static OpaquePtr make(PtrTy P)
Definition Ownership.h:60
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition Expr.h:1125
bool isEnabled(llvm::StringRef Ext) const
static OverloadableAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
MapType::iterator iterator
SmallVectorImpl< UniqueVirtualMethod >::iterator overriding_iterator
OwnershipKind getOwnKind() const
Definition Attr.h:8128
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
Definition Attr.h:228
Expr ** getExprs()
Definition Expr.h:5493
unsigned getNumExprs() const
Return the number of expressions in this paren list.
Definition Expr.h:5482
void setRParenLoc(SourceLocation Loc)
Definition TypeLoc.h:1129
TypeLoc getInnerLoc() const
Definition TypeLoc.h:1142
void setLParenLoc(SourceLocation Loc)
Definition TypeLoc.h:1125
Sugar for parentheses used when specifying types.
Definition Type.h:2598
Represents a parameter to a function.
Definition Decl.h:1620
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition Decl.h:1680
ObjCDeclQualifier getObjCDeclQualifier() const
Definition Decl.h:1684
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition Decl.h:1653
QualType getOriginalType() const
Definition Decl.cpp:2709
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition Decl.cpp:2700
ParsedAttr - Represents a syntactic attribute.
Definition ParsedAttr.h:200
bool hasAttribute(ParsedAttr::Kind K) const
Definition ParsedAttr.h:898
ParsedAttributes - A collection of parsed attributes.
Definition ParsedAttr.h:914
AttributePool & getPool() const
Definition ParsedAttr.h:919
int getType() const
Definition Attr.h:8275
bool isDynamic() const
Definition Attr.h:8272
PipeType - OpenCL20.
Definition Type.h:6260
TypeLoc getPointeeLoc() const
Definition TypeLoc.h:1208
Wrapper for source info for pointers.
Definition TypeLoc.h:1227
void setStarLoc(SourceLocation Loc)
Definition TypeLoc.h:1233
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition Type.h:2624
QualType getPointeeType() const
Definition Type.h:2634
static PragmaClangBSSSectionAttr * CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static PragmaClangDataSectionAttr * CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static PragmaClangRelroSectionAttr * CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static PragmaClangRodataSectionAttr * CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static PragmaClangTextSectionAttr * CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo={SourceRange{}})
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
HeaderSearch & getHeaderSearchInfo() const
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
StringRef getLastMacroWithSpelling(SourceLocation Loc, ArrayRef< TokenValue > Tokens) const
Return the name of the macro defined before Loc that has spelling Tokens.
static PureAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
A (possibly-)qualified type.
Definition Type.h:661
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition Type.h:6482
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
Definition Type.h:6554
@ DK_nontrivial_c_struct
Definition Type.h:1195
PrimitiveDefaultInitializeKind
Definition Type.h:1123
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
Definition Type.cpp:2477
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
Definition Type.cpp:73
QualType withoutLocalFastQualifiers() const
Definition Type.h:889
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition Type.h:726
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition Type.cpp:2512
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition Type.h:6412
LangAS getAddressSpace() const
Return the address space of this type.
Definition Type.h:6533
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Definition Type.h:6548
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition Type.h:6439
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition Type.h:1108
QualType getCanonicalType() const
Definition Type.h:6451
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition Type.h:6492
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
Definition Type.cpp:2496
bool isObjCGCStrong() const
true when Type is objc's strong.
Definition Type.h:1103
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition Type.h:6471
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
Definition Type.h:1202
bool isCanonical() const
Definition Type.h:6456
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Definition Type.h:980
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition Type.h:1003
bool hasNonTrivialObjCLifetime() const
Definition Type.h:1112
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition Type.cpp:2329
@ PCK_Trivial
The type does not fall into any of the following categories.
Definition Type.h:1153
@ PCK_VolatileTrivial
The type would be trivial except that it is volatile-qualified.
Definition Type.h:1158
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
Definition Type.h:6542
A qualifier set is used to build a set of qualifiers.
Definition Type.h:6352
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition Type.h:6359
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition Type.cpp:3680
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
Definition Type.h:173
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
Definition Type.h:166
@ OCL_None
There is no lifetime qualification on this type.
Definition Type.h:162
@ OCL_Weak
Reading or writing from this object requires a barrier call.
Definition Type.h:176
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
Definition Type.h:179
bool hasConst() const
Definition Type.h:262
void removeConst()
Definition Type.h:264
void addConst()
Definition Type.h:265
ObjCLifetime getObjCLifetime() const
Definition Type.h:335
bool empty() const
Definition Type.h:423
Represents a struct/union/class.
Definition Decl.h:3806
bool hasObjectMember() const
Definition Decl.h:3887
field_range fields() const
Definition Decl.h:4026
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
Definition Decl.cpp:4491
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition Decl.cpp:4510
virtual void completeDefinition()
Note that the definition of this type is now complete.
Definition Decl.cpp:4553
@ APK_CanNeverPassInRegs
The argument of this type cannot be passed directly in registers.
Definition Decl.h:3831
field_iterator field_begin() const
Definition Decl.cpp:4544
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition Type.h:4605
RecordDecl * getDecl() const
Definition Type.h:4615
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
Definition Expr.h:6337
void setMemberSpecialization()
Note that this member template is a specialization.
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
redecl_iterator redecls_end() const
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition Decl.h:4545
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
Definition Type.h:2735
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Definition Stmt.h:2729
void setNRVOCandidate(const VarDecl *Var)
Set the variable that might be used for the named return value optimization.
Definition Stmt.h:2777
static ReturnsNonNullAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
static ReturnsTwiceAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
Scope - A scope is a transient data structure that is used while parsing the program.
Definition Scope.h:40
bool isDeclScope(const Decl *D) const
isDeclScope - Return true if this is the scope that the specified decl is declared in.
Definition Scope.h:323
void RemoveDecl(Decl *D)
Definition Scope.h:293
DeclContext * getEntity() const
Get the entity corresponding to this scope.
Definition Scope.h:326
bool isCompoundStmtScope() const
Determine whether this scope is a compound statement scope.
Definition Scope.h:465
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition Scope.h:228
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
Definition Scope.h:77
@ DeclScope
This is a scope that can contain a declaration.
Definition Scope.h:59
static SectionAttr * CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo={SourceRange{}})
A RAII object to temporarily push a declaration context.
Definition Sema.h:968
A class which encapsulates the logic for delaying diagnostics during parsing and other processing.
Definition Sema.h:916
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
Definition Sema.h:928
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
static NameClassification DependentNonType()
Definition Sema.h:2419
static NameClassification VarTemplate(TemplateName Name)
Definition Sema.h:2429
static NameClassification Unknown()
Definition Sema.h:2399
static NameClassification OverloadSet(ExprResult E)
Definition Sema.h:2403
static NameClassification UndeclaredTemplate(TemplateName Name)
Definition Sema.h:2447
static NameClassification FunctionTemplate(TemplateName Name)
Definition Sema.h:2435
static NameClassification NonType(NamedDecl *D)
Definition Sema.h:2409
static NameClassification Concept(TemplateName Name)
Definition Sema.h:2441
static NameClassification UndeclaredNonType()
Definition Sema.h:2415
static NameClassification TypeTemplate(TemplateName Name)
Definition Sema.h:2423
static NameClassification Error()
Definition Sema.h:2395
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition Sema.h:8986
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition Sema.h:9017
A generic diagnostic builder for errors which may or may not be deferred.
Definition Sema.h:1629
Sema - This implements semantic analysis and AST building for C.
Definition Sema.h:340
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S)
MergeCXXFunctionDecl - Merge two declarations of the same C++ function, once we already know that the...
Attr * getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition)
Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a containing class.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
Definition Sema.h:3076
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition Sema.h:9044
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition Sema.h:12628
void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, LookupResult &OldDecls)
MergeTypedefNameDecl - We just parsed a typedef 'New' which has the same name and scope as a previous...
CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
Definition SemaCUDA.cpp:108
bool hasStructuralCompatLayout(Decl *D, Decl *Suggested)
Determine if D and Suggested have a structurally compatible layout as described in C11 6....
void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S)
Register the given locally-scoped extern "C" declaration so that it can be found later for redeclarat...
bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New)
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
void checkDeviceDecl(ValueDecl *D, SourceLocation Loc)
Check if the expression is allowed to be used in expressions for the offloading devices.
Definition Sema.cpp:1784
void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly.
InternalLinkageAttr * mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL)
ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth, bool *ZeroWidth=nullptr)
VerifyBitField - verifies that a bit field expression is an ICE and has the correct width,...
void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden)
Check whether the given new method is a valid override of the given overridden method,...
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false)
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
Decl * ActOnIvar(Scope *S, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, tok::ObjCKeywordKind visibility)
ActOnIvar - Each ivar field of an objective-c class is passed into this in order to create an IvarDec...
void DiagnoseUnusedParameters(ArrayRef< ParmVarDecl * > Parameters)
Diagnose any unused parameters in the given sequence of ParmVarDecl pointers.
Decl * ActOnParamDeclarator(Scope *S, Declarator &D)
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old)
Merge the exception specifications of two variable declarations.
LookupNameKind
Describes the kind of name lookup to perform.
Definition Sema.h:3893
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition Sema.h:3897
@ LookupNestedNameSpecifierName
Look up of a name that precedes the '::' scope resolution operator in C++.
Definition Sema.h:3916
@ LookupLocalFriendName
Look up a friend of a local class.
Definition Sema.h:3932
@ LookupRedeclarationWithLinkage
Look up an ordinary name that is going to be redeclared as a name with linkage.
Definition Sema.h:3929
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
Definition Sema.h:3905
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
Definition Sema.h:3900
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function.
void ActOnPopScope(SourceLocation Loc, Scope *S)
Scope actions.
Decl * ActOnSkippedFunctionBody(Decl *Decl)
QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, QualType Type, TypeSourceInfo *TSI, SourceRange Range, bool DirectInit, Expr *Init)
bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS)
SetMemberAccessSpecifier - Set the access specifier of a member.
NonTrivialCUnionContext
Definition Sema.h:2699
@ NTCUC_CopyInit
Definition Sema.h:2709
@ NTCUC_AutoVar
Definition Sema.h:2707
@ NTCUC_DefaultInitializedObject
Definition Sema.h:2705
@ NTCUC_FunctionReturn
Definition Sema.h:2703
@ NTCUC_FunctionParam
Definition Sema.h:2701
void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, uint64_t MagicValue, QualType Type, bool LayoutCompatible, bool MustBeNull)
Register a magic integral constant to be used as a type tag.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
Definition Sema.cpp:563
StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, IdentifierInfo *Ident, ParsedAttributes &Attrs, SourceLocation AttrEnd)
void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID)
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition Sema.cpp:1761
ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV)
void ActOnTagDefinitionError(Scope *S, Decl *TagDecl)
ActOnTagDefinitionError - Invoked when there was an unrecoverable error parsing the definition of a t...
void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body)
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
void ProcessPragmaWeak(Scope *S, Decl *D)
DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S, IdentifierInfo *II)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class,...
NoSpeculativeLoadHardeningAttr * mergeNoSpeculativeLoadHardeningAttr(Decl *D, const NoSpeculativeLoadHardeningAttr &AL)
void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, CXXRecordDecl *Record)
MarkBaseAndMemberDestructorsReferenced - Given a record decl, mark all the non-trivial destructors of...
void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, SourceRange BraceRange)
ActOnTagFinishDefinition - Invoked once we have finished parsing the definition of a tag (enumeration...
FunctionEmissionStatus
Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.
Definition Sema.h:4106
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
Definition Sema.h:820
PragmaClangSection PragmaClangRodataSection
Definition Sema.h:462
NamedDecl * ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S)
ImplicitlyDefineFunction - An undeclared identifier was used in a function call, forming a call to an...
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Definition Sema.h:811
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition Sema.h:1123
void AddPragmaAttributes(Scope *S, Decl *D)
Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...
Definition SemaAttr.cpp:944
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition Sema.h:1365
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
Definition Sema.h:840
void ActOnExitFunctionContext()
bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, const TemplateArgumentListInfo &ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given dependent function template specialization.
DeduceAutoResult DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result, Optional< unsigned > DependentDeductionDepth=None, bool IgnoreConstraints=false)
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Definition Sema.cpp:2002
Preprocessor & getPreprocessor() const
Definition Sema.h:1524
void deduceOpenCLAddressSpace(ValueDecl *decl)
PragmaStack< StringLiteral * > CodeSegStack
Definition Sema.h:682
void AddRangeBasedOptnone(FunctionDecl *FD)
Only called on function definitions; if there is a pragma in scope with the effect of a range-based o...
Definition SemaAttr.cpp:993
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckForFunctionMarkedFinal - Checks whether a virtual member function overrides a virtual member fun...
static NamedDecl * getAsTemplateNameDecl(NamedDecl *D, bool AllowFunctionTemplates=true, bool AllowDependent=true)
Try to interpret the lookup result D as a template-name.
bool CheckForConstantInitializer(Expr *e, QualType t)
type checking declaration initializers (C99 6.7.8)
WebAssemblyImportNameAttr * mergeImportNameAttr(Decl *D, const WebAssemblyImportNameAttr &AL)
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic=false)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
void handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl)
AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared special functions,...
void AddAlignmentAttributesForRecord(RecordDecl *RD)
AddAlignmentAttributesForRecord - Adds any needed alignment attributes to a the record decl,...
Definition SemaAttr.cpp:50
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
void CheckMain(FunctionDecl *FD, const DeclSpec &D)
void setCurrentOpenCLExtensionForDecl(Decl *FD)
Set current OpenCL extensions for a declaration which can only be used when these OpenCL extensions a...
Definition Sema.cpp:2477
void AddKnownFunctionAttributes(FunctionDecl *FD)
Adds any function attributes that we know a priori based on the declaration of this function.
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition Sema.h:1067
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
EnforceTCBAttr * mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL)
FieldDecl * HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS)
HandleField - Analyze a field of a C struct or a C++ data member.
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs)
ActOnDependentIdExpression - Handle a dependent id-expression that was just parsed.
void ActOnReenterFunctionContext(Scope *S, Decl *D)
Push the parameters of D, which must be a function, into scope.
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type.
Definition SemaDecl.cpp:284
Decl * getObjCDeclContext() const
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S)
isTagName() - This method is called for error recovery purposes only to determine if the specified na...
Definition SemaDecl.cpp:609
llvm::DenseMap< const EnumDecl *, llvm::APInt > FlagBitsCache
A cache of the flags available in enumerations with the flag_bits attribute.
Definition Sema.h:1356
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
Decl * ActOnFileScopeAsmDecl(Expr *expr, SourceLocation AsmLoc, SourceLocation RParenLoc)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
ASTContext & Context
Definition Sema.h:399
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
DiagnosticsEngine & getDiagnostics() const
Definition Sema.h:1522
VisibilityAttr * mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, VisibilityAttr::VisibilityType Vis)
bool LookupBuiltin(LookupResult &R)
Lookup a builtin function, when name lookup would otherwise fail.
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition SemaDecl.cpp:56
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
UnusedFileScopedDeclsType UnusedFileScopedDecls
The set of file scoped decls seen so far that have not been used and must warn if not used.
Definition Sema.h:861
NamedDecl * LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, Scope *S, bool ForRedeclaration, SourceLocation Loc)
LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope.
ASTContext & getASTContext() const
Definition Sema.h:1525
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
bool checkMSInheritanceAttrOnDefinition(CXXRecordDecl *RD, SourceRange Range, bool BestCase, MSInheritanceModel SemanticSpelling)
SwiftNameAttr * mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA, StringRef Name)
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)
isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether 'this' shows up in the type of a static member function after the (naturally empty) cv-...
void DiagnoseUnguardedAvailabilityViolations(Decl *FD)
Issue any -Wunguarded-availability warnings in FD.
void PopExpressionEvaluationContext()
PragmaStack< StringLiteral * > ConstSegStack
Definition Sema.h:681
bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S)
isMicrosoftMissingTypename - In Microsoft mode, within class scope, if a CXXScopeSpec's type is equal...
Definition SemaDecl.cpp:642
SmallVector< VarDecl *, 4 > ExternalDeclarations
All the external declarations encoutered and used in the TU.
Definition Sema.h:853
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R, bool HasTrailingLParen)
void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord)
Add gsl::Pointer attribute to std::container::iterator.
Definition SemaAttr.cpp:108
bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn)
We've just determined that Old and New both appear to be definitions of the same variable.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition Sema.h:2915
Decl * BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy)
BuildAnonymousStructOrUnion - Handle the declaration of an anonymous structure or union.
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition Sema.cpp:1348
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
Definition Sema.h:7750
AvailabilityAttr * mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform, bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, int Priority)
Attribute merging methods. Return true if a new attribute was added.
EnumDecl * getStdAlignValT() const
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
Definition Sema.h:1098
CommonAttr * mergeCommonAttr(Decl *D, const ParsedAttr &AL)
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
bool UnifySection(StringRef SectionName, int SectionFlags, NamedDecl *TheDecl)
Definition SemaAttr.cpp:595
void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld)
MergeVarDeclTypes - We parsed a variable 'New' which has the same name and scope as a previous declar...
llvm::DenseMap< IdentifierInfo *, AsmLabelAttr * > ExtnameUndeclaredIdentifiers
ExtnameUndeclaredIdentifiers - Identifiers contained in #pragma redefine_extname before declared.
Definition Sema.h:1073
OptimizeNoneAttr * mergeOptimizeNoneAttr(Decl *D, const AttributeCommonInfo &CI)
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
void PushFunctionScope()
Enter a new function scope.
Definition Sema.cpp:1897
ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS, NamedDecl *Found, SourceLocation NameLoc, const Token &NextToken)
Act on the result of classifying a name as a specific non-type declaration.
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
void CheckDeductionGuideDeclarator(Declarator &D, QualType &R, StorageClass &SC)
Check the validity of a declarator that we parsed for a deduction-guide.
void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, ObjCIvarDecl **Fields, unsigned nIvars, SourceLocation Loc)
CheckImplementationIvars - This routine checks if the instance variables listed in the implelementati...
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
Definition SemaAttr.cpp:164
Decl * ActOnObjCContainerStartDefinition(Decl *IDecl)
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition Sema.cpp:52
sema::LambdaScopeInfo * PushLambdaScope()
Definition Sema.cpp:1914
@ UPPC_FixedUnderlyingType
The fixed underlying type of an enumeration.
Definition Sema.h:7934
@ UPPC_EnumeratorValue
The enumerator value.
Definition Sema.h:7937
@ UPPC_Initializer
An initializer.
Definition Sema.h:7949
@ UPPC_DeclarationType
The type of an arbitrary declaration.
Definition Sema.h:7922
@ UPPC_DeclarationQualifier
A declaration qualifier.
Definition Sema.h:7946
@ UPPC_DataMemberType
The type of a data member.
Definition Sema.h:7925
@ UPPC_BitFieldWidth
The size of a bit-field.
Definition Sema.h:7928
void checkAllowedCUDAInitializer(VarDecl *VD)
Definition SemaCUDA.cpp:515
const LangOptions & getLangOpts() const
Definition Sema.h:1518
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
void ActOnObjCTemporaryExitContainerContext(DeclContext *DC)
Invoked when we must temporarily exit the objective-c container scope for parsing/looking-up C constr...
bool RebuildTemplateParamsInCurrentInstantiation(TemplateParameterList *Params)
Rebuild the template parameters now that we know we're in a current instantiation.
void DiagnoseInvalidJumps(Stmt *Body)
SourceLocation CurInitSegLoc
Definition Sema.h:714
DLLImportAttr * mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI)
void EnterTemplatedContext(Scope *S, DeclContext *DC)
Enter a template parameter scope, after it's been associated with a particular DeclContext.
void CheckAlignasUnderalignment(Decl *D)
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
SectionAttr * mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
TypeVisibilityAttr * mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, TypeVisibilityAttr::VisibilityType Vis)
NamedDecl * findLocallyScopedExternCDecl(DeclarationName Name)
Look for a locally scoped extern "C" declaration by the given name.
bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old)
We've determined that New is a redeclaration of Old.
Preprocessor & PP
Definition Sema.h:398
bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, CheckConstexprKind Kind)
void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(Decl *D, SmallVectorImpl< FunctionDecl * > &Bases)
Register D as specialization of all base functions in Bases in the current omp begin/end declare vari...
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
NamedDecl * getShadowedDeclaration(const TypedefNameDecl *D, const LookupResult &R)
Return the declaration shadowed by the given typedef D, or null if it doesn't shadow any declaration ...
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
const LangOptions & LangOpts
Definition Sema.h:397
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition Sema.cpp:2108
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings=None)
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
CXXRecordDecl * getStdBadAlloc() const
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
PragmaClangSection PragmaClangRelroSection
Definition Sema.h:463
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM)
Diagnose why the specified class does not have a trivial special member of the given kind.
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
Definition SemaExpr.cpp:187
bool TemplateParameterListsAreEqual(TemplateParameterList *New, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
void CheckCXXDefaultArguments(FunctionDecl *FD)
CheckCXXDefaultArguments - Verify that the default arguments for a function declaration are well-form...
void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl, SourceLocation FinalLoc, bool IsFinalSpelledSealed, SourceLocation LBraceLoc)
ActOnStartCXXMemberDeclarations - Invoked when we have parsed a C++ record definition's base-specifie...
bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS)
checkUnsafeAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained type.
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
void MaybeAddCUDAConstantAttr(VarDecl *VD)
May add implicit CUDAConstantAttr attribute to VD, depending on VD and current compilation settings.
Definition SemaCUDA.cpp:635
TypeLoc getReturnTypeLoc(FunctionDecl *FD) const
bool canDelayFunctionBody(const Declarator &D)
Determine whether we can delay parsing the body of a function or function template until it is used,...
PragmaStack< StringLiteral * > BSSSegStack
Definition Sema.h:680
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true, bool AllowNonTemplateFunctions=false)
DeclContext * getCurLexicalContext() const
Definition Sema.h:12639
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl)
CheckOverloadedOperatorDeclaration - Check whether the declaration of this overloaded operator is wel...
NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, CorrectionCandidateCallback *CCC=nullptr)
Perform name lookup on the given name, classifying it based on the results of name lookup and the fol...
Definition SemaDecl.cpp:852
NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK)
Given a non-tag type declaration, returns an enum useful for indicating what kind of non-tag type thi...
void ExitDeclaratorContext(Scope *S)
bool isInOpenMPDeclareTargetContext() const
Return true inside OpenMP declare target region.
Definition Sema.h:10471
void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI)
Diagnose shadowing for variables shadowed in the lambda record LambdaRD when these variables are capt...
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
void AddCFAuditedAttribute(Decl *D)
AddCFAuditedAttribute - Check whether we're currently within '#pragma clang arc_cf_code_audited' and,...
Definition SemaAttr.cpp:719
FormatAttr * mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Format, int FormatIdx, int FirstArg)
void CheckMSVCRTEntryPoint(FunctionDecl *FD)
Decl * ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant, SourceLocation IdLoc, IdentifierInfo *Id, const ParsedAttributesView &Attrs, SourceLocation EqualLoc, Expr *Val)
sema::FunctionScopeInfo * getCurFunction() const
Definition Sema.h:1830
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
FunctionDecl * CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID, SourceLocation Loc)
Scope * getNonFieldDeclScope(Scope *S)
getNonFieldDeclScope - Retrieves the innermost scope, starting from S, where a non-field would be dec...
void ActOnPragmaWeakID(IdentifierInfo *WeakName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc)
ActOnPragmaWeakID - Called on well formed #pragma weak ident.
bool CheckNontrivialField(FieldDecl *FD)
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
Definition SemaExpr.cpp:210
void AddPushedVisibilityAttribute(Decl *RD)
AddPushedVisibilityAttribute - If '#pragma GCC visibility' was used, add an appropriate visibility at...
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether 'this' shows up in the attributes of the given static member function.
bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev, SkipBodyInfo &SkipBody)
Perform ODR-like check for C/ObjC when merging tag types from modules.
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S, bool MergeTypeWithOld)
MergeFunctionDecl - We just parsed a function 'New' from declarator D which has the same name and sco...
bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous)
Perform semantic checking on a newly-created variable declaration.
ExprResult DefaultLvalueConversion(Expr *E)
Definition SemaExpr.cpp:623
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
Definition Sema.h:2154
StringLiteral * CurInitSeg
Last section used with #pragma init_seg.
Definition Sema.h:713
bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD)
AddOverriddenMethods - See if a method overrides any in the base classes, and if so,...
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init)
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition Sema.h:411
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
Definition Sema.h:3947
@ NotForRedeclaration
The lookup is a reference to this name that is not for the purpose of redeclaring the name.
Definition Sema.h:3950
@ ForVisibleRedeclaration
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition Sema.h:3953
@ ForExternalRedeclaration
The lookup results will be used for redeclaration of a name with external linkage; non-visible lookup...
Definition Sema.h:3957
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true, bool ConsiderRequiresClauses=true)
void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D)
Act on D, a function definition inside of an omp [begin/end] assumes.
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
TypeSourceInfo * RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, SourceLocation Loc, DeclarationName Name)
Rebuilds a type within the context of the current instantiation.
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD, const LookupResult &Previous)
May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD, depending on FD and the current co...
Definition SemaCUDA.cpp:586
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
void CheckShadowingDeclModification(Expr *E, SourceLocation Loc)
Warn if 'E', which is an expression that is about to be modified, refers to a shadowing declaration.
SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc)
Determine whether the body of an anonymous enumeration should be skipped.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
void notePreviousDefinition(const NamedDecl *Old, SourceLocation New)
bool isInOpenMPDeclareVariantScope() const
Can we exit an OpenMP declare variant scope at the moment.
Definition Sema.h:10266
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization)
Perform semantic checking of a new function declaration.
DeclContext * OriginalLexicalContext
Generally null except when we temporarily switch decl contexts, like in.
Definition Sema.h:415
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
bool canSkipFunctionBody(Decl *D)
Determine whether we can skip parsing the body of a function definition, assuming we don't care about...
bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD, QualType NewT, QualType OldT)
Determines if we can perform a correct type check for D as a redeclaration of PrevDecl.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition Sema.h:8948
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
Definition Sema.h:2944
@ NTK_Typedef
Definition Sema.h:2949
@ NTK_NonUnion
Definition Sema.h:2947
@ NTK_TypeAlias
Definition Sema.h:2950
@ NTK_NonClass
Definition Sema.h:2946
@ NTK_NonEnum
Definition Sema.h:2948
@ NTK_NonStruct
Definition Sema.h:2945
@ NTK_TemplateTemplateArgument
Definition Sema.h:2953
@ NTK_TypeAliasTemplate
Definition Sema.h:2952
@ NTK_Template
Definition Sema.h:2951
void ActOnObjCContainerFinishDefinition()
SourceManager & getSourceManager() const
Definition Sema.h:1523
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, Scope *S, bool MergeTypeWithOld)
Completes the merge of two function declarations that are known to be compatible.
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, const ParsedAttributesView &Attr)
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
bool areMultiversionVariantFunctionsCompatible(const FunctionDecl *OldFD, const FunctionDecl *NewFD, const PartialDiagnostic &NoProtoDiagID, const PartialDiagnosticAt &NoteCausedDiagIDAt, const PartialDiagnosticAt &NoSupportDiagIDAt, const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported, bool ConstexprSupported, bool CLinkageMayDiffer)
Checks if the variant/multiversion functions are compatible.
void ActOnTagStartDefinition(Scope *S, Decl *TagDecl)
ActOnTagStartDefinition - Invoked when we have entered the scope of a tag's definition (e....
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
PragmaClangSection PragmaClangTextSection
Definition Sema.h:464
@ NTCUK_Destruct
Definition Sema.h:2729
@ NTCUK_Init
Definition Sema.h:2728
@ NTCUK_Copy
Definition Sema.h:2730
CodeSegAttr * mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
PragmaClangSection PragmaClangDataSection
Definition Sema.h:461
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, SmallVectorImpl< FunctionDecl * > &Bases)
The declarator D defines a function in the scope S which is nested in an omp begin/end declare varian...
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true)
void * SkippedDefinitionContext
Definition Sema.h:3105
ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, SourceLocation NameLoc)
Act on the result of classifying a name as an undeclared (ADL-only) non-type declaration.
void ActOnObjCReenterContainerContext(DeclContext *DC)
void ActOnPragmaRedefineExtname(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaRedefineExtname - Called on well formed #pragma redefine_extname oldname newname.
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
void AddMsStructLayoutForRecord(RecordDecl *RD)
AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
Definition SemaAttr.cpp:86
MaybeODRUseExprSet MaybeODRUseExprs
Definition Sema.h:767
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
Helpers for dealing with blocks and functions.
void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W)
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
Perform semantic analysis for the given non-template member specialization.
MinSizeAttr * mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI)
ObjCInterfaceDecl * getObjCInterfaceDecl(IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
@ CTK_NonError
Definition Sema.h:4133
@ CTK_ErrorRecovery
Definition Sema.h:4134
void CheckCompleteVariableDeclaration(VarDecl *VD)
DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, ArrayRef< Decl * > Group)
void setFunctionHasBranchProtectedScope()
Definition Sema.cpp:2055
void MergeVarDecl(VarDecl *New, LookupResult &Previous)
MergeVarDecl - We just parsed a variable 'New' which has the same name and scope as a previous declar...
FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl, bool Final=false)
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
Definition Sema.h:1094
DeclResult ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization)
ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II, SourceLocation NameLoc, bool IsTemplateTypeArg)
Attempt to behave like MSVC in situations where lookup of an unqualified type name has failed in a de...
Definition SemaDecl.cpp:556
SpeculativeLoadHardeningAttr * mergeSpeculativeLoadHardeningAttr(Decl *D, const SpeculativeLoadHardeningAttr &AL)
@ CCEK_Enumerator
Enumerator value with fixed underlying type.
Definition Sema.h:3458
void ActOnLastBitfield(SourceLocation DeclStart, SmallVectorImpl< Decl * > &AllIvarDecls)
ActOnLastBitfield - This routine handles synthesized bitfields rules for class and class extensions.
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition Sema.cpp:1343
CUDAFunctionTarget
Definition Sema.h:11982
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
void MarkUnusedFileScopedDecl(const DeclaratorDecl *D)
If it's a file scoped decl that must warn if not used, keep track of it.
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
ASTConsumer & Consumer
Definition Sema.h:400
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool IsForUsingDecl)
Determine whether the given New declaration is an overload of the declarations in Old.
@ Ovl_NonFunction
This is not an overload because the lookup results contain a non-function.
Definition Sema.h:3357
@ Ovl_Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
Definition Sema.h:3349
@ Ovl_Match
This is not an overload because the signature exactly matches an existing declaration.
Definition Sema.h:3353
SmallVector< ExprWithCleanups::CleanupObject, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
Definition Sema.h:758
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
Definition Sema.h:9062
bool hasUncompilableErrorOccurred() const
Whether uncompilable error has occurred.
Definition Sema.cpp:1471
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted.
WebAssemblyImportModuleAttr * mergeImportModuleAttr(Decl *D, const WebAssemblyImportModuleAttr &AL)
void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(FunctionDecl *FD)
If this function is a C++ replaceable global allocation function (C++2a [basic.stc....
bool inferObjCARCLifetime(ValueDecl *decl)
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
AvailabilityMergeKind
Describes the kind of merge to perform for availability attributes (including "deprecated",...
Definition Sema.h:3222
@ AMK_None
Don't merge availability attributes at all.
Definition Sema.h:3224
@ AMK_Override
Merge availability attributes for an override, which requires an exact match or a weakening of constr...
Definition Sema.h:3230
@ AMK_ProtocolImplementation
Merge availability attributes for an implementation of a protocol requirement.
Definition Sema.h:3233
@ AMK_Redeclaration
Merge availability attributes for a redeclaration, which requires an exact match.
Definition Sema.h:3227
void ActOnDocumentableDecls(ArrayRef< Decl * > Group)
void CheckStaticLocalForDllExport(VarDecl *VD)
Check if VD needs to be dllexport/dllimport due to being in a dllexport/import function.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
UuidAttr * mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI, StringRef UuidAsWritten, MSGuidDecl *GuidDecl)
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
Definition SemaStmt.cpp:72
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls)
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition Sema.h:1091
void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context)
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
EnforceTCBLeafAttr * mergeEnforceTCBLeafAttr(Decl *D, const EnforceTCBLeafAttr &AL)
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl)
Checks if the new declaration declared in dependent context must be put in the same redeclaration cha...
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition Sema.h:850
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
void DiscardCleanupsInEvaluationContext()
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition Sema.h:1299
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
void makeMergedDefinitionVisible(NamedDecl *ND)
Make a merged definition of an existing hidden definition ND visible at the specified location.
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
Definition Sema.h:402
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness,...
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
Decl * BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, RecordDecl *Record)
BuildMicrosoftCAnonymousStruct - Handle the declaration of an Microsoft C anonymous structure.
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL, bool IncludeCXX11Attributes=true)
DiagnosticsEngine & Diags
Definition Sema.h:401
OpenCLOptions & getOpenCLOptions()
Definition Sema.h:1519
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, RecordDecl *&AnonRecord)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e....
NamespaceDecl * getStdNamespace() const
RedeclarationKind forRedeclarationInCurContext()
Definition Sema.h:3960
NamedDecl * ActOnTypedefDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous)
PragmaStack< StringLiteral * > DataSegStack
Definition Sema.h:679
void deduceClosureReturnType(sema::CapturingScopeInfo &CSI)
Deduce a block or lambda's return type based on the return statements present in the body.
@ TUK_Definition
Definition Sema.h:2968
@ TUK_Declaration
Definition Sema.h:2967
@ TUK_Friend
Definition Sema.h:2969
@ TUK_Reference
Definition Sema.h:2966
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D)
Common checks for a parameter-declaration that should apply to both function parameters and non-type ...
@ TPC_FriendFunctionTemplate
Definition Sema.h:7477
@ TPC_ClassTemplateMember
Definition Sema.h:7475
@ TPC_FunctionTemplate
Definition Sema.h:7474
@ TPC_FriendFunctionTemplateDefinition
Definition Sema.h:7478
@ TPC_VarTemplate
Definition Sema.h:7473
NamedDecl * ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *D, LookupResult &Previous, bool &Redeclaration)
ActOnTypedefNameDecl - Perform semantic checking for a declaration which declares a typedef-name,...
void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs)
ActOnFinishDelayedAttribute - Invoked when we have finished parsing an attribute for which parsing is...
void DiagnoseUnusedDecl(const NamedDecl *ND)
DiagnoseUnusedDecl - Emit warnings about declarations that are not used unless they are marked attr(u...
void PopDeclContext()
void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID)
DiagnoseDuplicateIvars - Check for duplicate ivars in the entire class at the start of @implementatio...
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition Sema.h:1390
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
void ActOnUninitializedDecl(Decl *dcl)
void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc)
Emit diagnostics if the initializer or any of its explicit or implicitly-generated subexpressions req...
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
TypedefDecl * ParseTypedefDecl(Scope *S, Declarator &D, QualType T, TypeSourceInfo *TInfo)
Subroutines of ActOnDeclarator().
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
Definition Sema.cpp:2092
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, const AttributeCommonInfo &CI, const IdentifierInfo *Ident)
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec.
Decl * ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth)
ActOnField - Each field of a C struct/union is passed into this in order to create a FieldDecl object...
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &... Args)
Definition Sema.h:2235
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
void ActOnCXXForRangeDecl(Decl *D)
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant,...
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, bool IsTemplateId)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
std::tuple< MangleNumberingContext *, Decl * > getCurrentMangleNumberContext(const DeclContext *DC)
Compute the mangling number context for a lambda expression or block literal.
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
PragmaClangSection PragmaClangBSSSection
Definition Sema.h:460
Decl * ActOnDeclarator(Scope *S, Declarator &D)
@ AbstractVariableType
Definition Sema.h:7282
@ AbstractReturnType
Definition Sema.h:7280
@ AbstractFieldType
Definition Sema.h:7283
@ AbstractParamType
Definition Sema.h:7281
@ AbstractIvarType
Definition Sema.h:7284
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
Definition Sema.h:1102
ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, bool IsAddressOfOperand)
Act on the result of classifying a name as an undeclared member of a dependent base class.
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
void ActOnPragmaWeakAlias(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
void CheckVariableDeclarationType(VarDecl *NewVD)
unsigned getTemplateDepth(Scope *S) const
Determine the number of levels of enclosing template parameters.
CXXSpecialMember
Kinds of C++ special members.
Definition Sema.h:1427
@ CXXCopyConstructor
Definition Sema.h:1429
@ CXXDestructor
Definition Sema.h:1433
@ CXXDefaultConstructor
Definition Sema.h:1428
@ CXXInvalid
Definition Sema.h:1434
@ CXXCopyAssignment
Definition Sema.h:1431
SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD)
Invoked when we enter a tag definition that we're skipping.
bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit, Expr *Init)
std::string getCudaConfigureFuncName() const
Returns the name of the launch configuration function.
Definition SemaCUDA.cpp:858
@ DAR_Failed
Definition Sema.h:8420
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
llvm::SmallPtrSet< const NamedDecl *, 4 > TypoCorrectedFunctionDefinitions
The function definitions which were renamed as part of typo-correction to match their respective decl...
Definition Sema.h:1467
Decl * ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope)
Given the set of return statements within a function body, compute the variables that are subject to ...
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
IdentifierResolver IdResolver
Definition Sema.h:1086
bool isSimpleTypeSpecifier(tok::TokenKind Kind) const
Determine whether the token kind starts a simple-type-specifier.
Definition SemaDecl.cpp:125
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, UnresolvedLookupExpr *AsULE=nullptr)
Builds an expression which might be an implicit member expression.
bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, bool AllowMask) const
IsValueInFlagEnum - Determine if a value is allowed as part of a flag enum.
void DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName=false)
Definition SemaDecl.cpp:658
void DiagnoseSizeOfParametersAndReturnValue(ArrayRef< ParmVarDecl * > Parameters, QualType ReturnTy, NamedDecl *D)
Diagnose whether the size of parameters or return value of a function or obj-c method definition is p...
void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD)
llvm::SmallVector< std::pair< SourceLocation, const BlockDecl * >, 1 > ImplicitlyRetainedSelfLocs
List of SourceLocations where 'self' is implicitly retained inside a block.
Definition Sema.h:1424
TemplateNameKindForDiagnostics
Describes the detailed kind of a template name. Used in diagnostics.
Definition Sema.h:2540
void checkCUDATargetOverload(FunctionDecl *NewFD, const LookupResult &Previous)
Check whether NewFD is a valid overload for CUDA.
Definition SemaCUDA.cpp:811
DLLExportAttr * mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI)
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool IsFixed, const EnumDecl *Prev)
Check whether this is a valid redeclaration of a previous enumeration.
MSInheritanceAttr * mergeMSInheritanceAttr(Decl *D, const AttributeCommonInfo &CI, bool BestCase, MSInheritanceModel Model)
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD=nullptr)
Definition Sema.cpp:1745
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Definition Sema.h:6328
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet)
Act on the result of classifying a name as an overload set.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include'd file otherwise it returns an invalid location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
StringRef getFilename(SourceLocation SpellingLoc) const
Return the filename of the file containing a SourceLocation.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
Definition Stmt.h:68
child_range children()
Definition Stmt.cpp:285
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition Stmt.cpp:324
SourceLocation getBeginLoc() const LLVM_READONLY
Definition Stmt.cpp:336
static StrictFPAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
StringLiteral - This represents a string literal expression, e.g.
Definition Expr.h:1758
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
Definition Expr.h:1902
StringRef getString() const
Definition Expr.h:1838
Represents the declaration of a struct/union/class/enum.
Definition Decl.h:3277
static TagDecl * castFromDeclContext(const DeclContext *DC)
Definition Decl.h:3529
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition Decl.h:3400
TagDecl * getDefinition() const
Returns the TagDecl that actually defines this struct/union/class/enum.
Definition Decl.cpp:4281
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
Definition Decl.h:3375
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
Definition Decl.h:3361
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition Decl.h:3380
void startDefinition()
Starts the definition of this tag declaration.
Definition Decl.cpp:4258
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
Definition Decl.cpp:4249
bool isUnion() const
Definition Decl.h:3463
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition Decl.cpp:4304
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Definition Decl.cpp:4324
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type?
Definition Decl.h:3481
TagKind getTagKind() const
Definition Decl.h:3454
ParsedTargetAttr parse() const
Definition Attr.h:10264
bool isDefaultVersion() const
Definition Attr.h:10308
llvm::StringRef getFeaturesStr() const
Definition Attr.h:10250
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool canKeyFunctionBeInline() const
Can an out-of-line inline function serve as a key function?
Exposes information about the current target.
Definition TargetInfo.h:180
virtual bool validateCpuIs(StringRef Name) const
unsigned getShortWidth() const
Return the size of 'signed short' and 'unsigned short' for this target, in bits.
Definition TargetInfo.h:426
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
Definition TargetInfo.h:434
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
Definition TargetInfo.h:444
bool isTLSSupported() const
Whether the target supports thread-local storage.
unsigned getMaxTLSAlign() const
Return the maximum alignment (in bits) of a TLS variable.
virtual bool validateCpuSupports(StringRef Name) const
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool isValidFeatureName(StringRef Feature) const
Determine whether this TargetInfo supports the given feature.
unsigned getCharWidth() const
Definition TargetInfo.h:421
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
Definition TargetInfo.h:439
bool supportsMultiVersioning() const
Identify whether this target supports multiversioning of functions, which requires support for cpu_su...
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
virtual bool allowDebugInfoForExternalVar() const
Whether target allows debuginfo types for decl only variables.
virtual bool isValidGCCRegisterName(StringRef Name) const
Returns whether the passed in string is a valid register name according to GCC.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation getRAngleLoc() const
SourceLocation getTemplateLoc() const
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition Type.h:5097
static bool anyInstantiationDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args)
Definition Type.cpp:3614
Token - This structure provides full information about a lexed token.
Definition Token.h:34
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....
Definition Token.h:97
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition Token.h:99
bool isNot(tok::TokenKind K) const
Definition Token.h:98
Represents a declaration of a type.
Definition Decl.h:3085
void setTypeForDecl(const Type *TD)
Definition Decl.h:3110
const Type * getTypeForDecl() const
Definition Decl.h:3109
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
Base wrapper for a particular "section" of type source info.
Definition TypeLoc.h:58
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
Definition TypeLoc.h:326
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition TypeLoc.h:132
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition TypeLoc.h:88
TypeLoc IgnoreParens() const
Definition TypeLoc.h:1151
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
Definition TypeLoc.h:77
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
Definition TypeLoc.h:202
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition TypeLoc.h:152
SourceLocation getEndLoc() const
Get the end source location.
Definition TypeLoc.cpp:228
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition TypeLoc.h:2547
SourceLocation getBeginLoc() const
Get the begin source location.
Definition TypeLoc.cpp:191
A container of type source information.
Definition Type.h:6383
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition TypeLoc.h:244
QualType getType() const
Return the type wrapped by this type source info.
Definition Type.h:6394
void setNameLoc(SourceLocation Loc)
Definition TypeLoc.h:527
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition Type.h:5379
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition Type.cpp:2802
The base class of the type hierarchy.
Definition Type.h:1478
bool isStructureType() const
Definition Type.cpp:563
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition Type.cpp:1753
bool isBlockPointerType() const
Definition Type.h:6668
bool isVoidType() const
Definition Type.h:6943
bool isBooleanType() const
Definition Type.h:7055
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition Type.cpp:2022
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
Definition Type.cpp:1770
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
Definition Type.h:7102
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition Type.cpp:660
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition Type.cpp:2534
bool isIncompleteArrayType() const
Definition Type.h:6734
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition Type.cpp:4017
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
Definition Type.h:7219
bool isConstantArrayType() const
Definition Type.h:6730
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
Definition Type.h:7082
bool isArrayType() const
Definition Type.h:6726
bool isFunctionPointerType() const
Definition Type.h:6694
bool isPointerType() const
Definition Type.h:6660
const T * castAs() const
Member-template castAs<specific type>.
Definition Type.h:7210
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition Type.cpp:2730
bool isReferenceType() const
Definition Type.h:6672
bool isScalarType() const
Definition Type.h:7026
bool isClkEventT() const
Definition Type.h:6855
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition Type.cpp:1915
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition Type.cpp:625
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition Type.h:7042
bool isImageType() const
Definition Type.h:6867
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
Definition Type.h:2266
bool isPipeType() const
Definition Type.h:6874
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition Type.h:2161
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
Definition Type.cpp:2182
bool isHalfType() const
Definition Type.h:6947
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
Definition Type.cpp:1879
const RecordType * getAsStructureType() const
Definition Type.cpp:641
bool containsErrors() const
Whether this type is an error type.
Definition Type.h:2155
bool isFunctionProtoType() const
Definition Type.h:2006
bool isObjCIdType() const
Definition Type.h:6815
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition Type.h:2179
bool isObjCObjectType() const
Definition Type.h:6786
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition Type.h:7061
bool isEventT() const
Definition Type.h:6851
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
Definition Type.cpp:2206
const T * getAsAdjusted() const
Member-template getAsAdjusted<specific type>.
Definition Type.h:7162
bool isFunctionType() const
Definition Type.h:6656
bool isObjCObjectPointerType() const
Definition Type.h:6782
bool isMemberFunctionPointerType() const
Definition Type.h:6712
bool isFloatingType() const
Definition Type.cpp:2093
bool isAnyPointerType() const
Definition Type.h:6664
bool hasAutoForTrailingReturnType() const
Determine whether this type was written with a leading 'auto' corresponding to a trailing return type...
Definition Type.cpp:1884
bool isSamplerT() const
Definition Type.h:6847
const T * getAs() const
Member-template getAs<specific type>'.
Definition Type.h:7145
bool isNullPtrType() const
Definition Type.h:6964
bool isRecordType() const
Definition Type.h:6750
bool isUnionType() const
Definition Type.cpp:595
bool isFunctionNoProtoType() const
Definition Type.h:2005
bool isReserveIDT() const
Definition Type.h:6863
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
Definition Type.cpp:1761
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Definition Decl.h:3229
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition Decl.cpp:4920
Base class for declarations which introduce a typedef-name.
Definition Decl.h:3127
TypeSourceInfo * getTypeSourceInfo() const
Definition Decl.h:3177
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
Definition Decl.h:3193
QualType getUnderlyingType() const
Definition Decl.h:3182
void setTypeSourceInfo(TypeSourceInfo *newType)
Definition Decl.h:3189
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes,...
Definition Decl.cpp:4928
Simple class containing the result of Sema::CorrectTypo.
IdentifierInfo * getCorrectionAsIdentifierInfo() const
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
decl_iterator begin()
SmallVectorImpl< NamedDecl * >::const_iterator const_decl_iterator
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
SmallVectorImpl< NamedDecl * >::iterator decl_iterator
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition Expr.h:2095
Expr * getSubExpr() const
Definition Expr.h:2140
Opcode getOpcode() const
Definition Expr.h:2135
static bool isIncrementDecrementOp(Opcode Op)
Definition Expr.h:2195
static UnavailableAttr * CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, ImplicitReason ImplicitReason, const AttributeCommonInfo &CommonInfo={SourceRange{}})
Represents a C++ unqualified-id that has been parsed.
Definition DeclSpec.h:950
UnqualifiedIdKind Kind
Describes the kind of unqualified-id parsed.
Definition DeclSpec.h:957
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition DeclSpec.h:1159
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition DeclSpec.h:1008
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition DeclSpec.h:1032
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition DeclSpec.h:1002
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition ExprCXX.cpp:368
The iterator over UnresolvedSets.
UsedAttr * clone(ASTContext &C) const
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition DeclCXX.h:3168
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition DeclCXX.h:3230
UsingDecl * getUsingDecl() const
Gets the using declaration to which this declaration is tied.
Definition DeclCXX.cpp:3003
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:634
void setType(QualType newType)
Definition Decl.h:646
QualType getType() const
Definition Decl.h:645
Represents a variable declaration or definition.
Definition Decl.h:834
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition Decl.cpp:2608
void setCXXForRangeDecl(bool FRD)
Definition Decl.h:1393
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition Decl.h:1437
TLSKind getTLSKind() const
Definition Decl.cpp:2010
bool hasInit() const
Definition Decl.cpp:2237
void setInitStyle(InitializationStyle Style)
Definition Decl.h:1320
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
Definition Decl.cpp:2103
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition Decl.cpp:2032
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member.
Definition Decl.cpp:2277
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition Decl.cpp:2100
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition Decl.h:1446
@ ListInit
Direct list-initialization (C++11)
Definition Decl.h:845
@ CallInit
Call-style initialization (C++98)
Definition Decl.h:842
void setStorageClass(StorageClass SC)
Definition Decl.cpp:2005
void setPreviousDeclInSameBlockScope(bool Same)
Definition Decl.h:1465
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition Decl.h:1158
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition Decl.h:1101
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition Decl.cpp:2205
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
Definition Decl.cpp:2302
void setInlineSpecified()
Definition Decl.h:1426
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition Decl.h:1083
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition Decl.cpp:1992
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
Definition Decl.h:1217
void setTSCSpec(ThreadStorageClassSpecifier TSC)
Definition Decl.h:1048
bool checkForConstantInitialization(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the initializer of this variable to determine whether it's a constant initializer.
Definition Decl.cpp:2468
bool isInline() const
Whether this variable is (C++1z) inline.
Definition Decl.h:1419
ThreadStorageClassSpecifier getTSCSpec() const
Definition Decl.h:1052
const Expr * getInit() const
Definition Decl.h:1243
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
Definition Decl.h:1092
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition Decl.h:1059
VarDecl * getInitializingDeclaration()
Get the initializing declaration of this variable, if any.
Definition Decl.cpp:2262
void setConstexpr(bool IC)
Definition Decl.h:1440
@ TLS_Static
TLS with a known-constant initializer.
Definition Decl.h:854
@ TLS_Dynamic
TLS with a dynamic initializer.
Definition Decl.h:857
void setInit(Expr *I)
Definition Decl.cpp:2293
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
Definition Decl.cpp:2188
@ TentativeDefinition
This declaration is a tentative definition.
Definition Decl.h:1173
@ DeclarationOnly
This declaration is only a declaration.
Definition Decl.h:1170
@ Definition
This declaration is definitely a definition.
Definition Decl.h:1176
void setDescribedVarTemplate(VarTemplateDecl *Template)
Definition Decl.cpp:2613
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
Definition Decl.cpp:2088
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
Definition Decl.h:1128
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition Decl.h:1043
void setImplicitlyInline()
Definition Decl.h:1431
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
Definition Decl.h:1344
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration's previous declaration was declared in the same block ...
Definition Decl.h:1460
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
Definition Decl.h:1137
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition Decl.cpp:2577
void demoteThisDefinitionToDeclaration()
This is a definition which should be demoted to a declaration.
Definition Decl.h:1354
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Definition Decl.cpp:2492
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
Represents a C array with a specified size that is not an integer-constant-expression.
Definition Type.h:3017
Expr * getSizeExpr() const
Definition Type.h:3036
static WeakAttr * CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo={SourceRange{}})
Captures information about a #pragma weak directive.
Definition Weak.h:24
bool isVariableCapture() const
Definition ScopeInfo.h:601
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
Definition ScopeInfo.h:637
VarDecl * getVariable() const
Definition ScopeInfo.h:626
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
Definition ScopeInfo.h:690
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition ScopeInfo.h:680
void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
Definition ScopeInfo.h:682
SmallVector< Capture, 4 > Captures
Captures - The captures.
Definition ScopeInfo.h:672
ImplicitCaptureStyle ImpCaptureStyle
Definition ScopeInfo.h:659
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, bool ByCopy)
Definition ScopeInfo.h:1039
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
Retains information about a function, method, or block that is currently being parsed.
Definition ScopeInfo.h:98
bool UsesFPIntrin
Whether this function uses constrained floating point intrinsics.
Definition ScopeInfo.h:131
void addByrefBlockVar(VarDecl *VD)
Definition ScopeInfo.h:464
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super's implementation, such as -dealloc,...
Definition ScopeInfo.h:140
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
Definition ScopeInfo.h:157
bool HasPotentialAvailabilityViolations
Whether we make reference to a declaration that could be unavailable.
Definition ScopeInfo.h:135
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
Definition ScopeInfo.h:148
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
Definition ScopeInfo.h:824
llvm::SmallVector< ShadowedOuterDecl, 4 > ShadowingDecls
Definition ScopeInfo.h:893
CXXRecordDecl * Lambda
The class that describes the lambda.
Definition ScopeInfo.h:818
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Definition ScopeInfo.h:821
bool Mutable
Whether this is a mutable lambda.
Definition ScopeInfo.h:835
Defines the clang::TargetInfo interface.
const AstTypeMatcher< RecordType > recordType
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an '@'.
Definition TokenKinds.h:41
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition TokenKinds.h:25
Dataflow Directional Tag Classes.
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
TypeSpecifierType
Specifies the kind of type.
Definition Specifiers.h:43
@ TST_struct
Definition Specifiers.h:68
@ TST_class
Definition Specifiers.h:69
@ TST_union
Definition Specifiers.h:67
@ TST_enum
Definition Specifiers.h:66
@ TST_interface
Definition Specifiers.h:70
bool isa(CodeGen::Address addr)
Definition Address.h:111
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition Specifiers.h:187
@ CPlusPlus20
@ CPlusPlus
@ CPlusPlus11
@ CPlusPlus14
@ CPlusPlus17
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition Ownership.h:276
@ GVA_AvailableExternally
Definition Linkage.h:75
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
Definition ASTLambda.h:81
ConstexprSpecKind
Define the kind of constexpr specifier.
Definition Specifiers.h:32
InClassInitStyle
In-class initialization styles for non-static data members.
Definition Specifiers.h:246
@ ICIS_NoInit
No in-class initializer.
Definition Specifiers.h:247
@ LCK_ByRef
Capturing by reference.
Definition Lambda.h:37
@ LCK_StarThis
Definition Lambda.h:35
@ IK_DeductionGuideName
A deduction-guide name (a template-name)
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_ConstructorTemplateId
A constructor named via a template-id.
@ IK_ConstructorName
A constructor name.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_DestructorName
A destructor name.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
@ IK_ConversionFunctionId
A conversion function name, e.g., operator int.
SmallVector< Attr *, 4 > AttrVec
AttrVec - A vector of Attr, which is how they are stored on the AST.
bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D)
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have.
Definition Linkage.h:64
@ CLanguageLinkage
Definition Linkage.h:65
@ CXXLanguageLinkage
Definition Linkage.h:66
StorageClass
Storage classes.
Definition Specifiers.h:223
@ SC_Auto
Definition Specifiers.h:231
@ SC_PrivateExtern
Definition Specifiers.h:228
@ SC_Extern
Definition Specifiers.h:226
@ SC_Register
Definition Specifiers.h:232
@ SC_Static
Definition Specifiers.h:227
@ SC_None
Definition Specifiers.h:225
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition Specifiers.h:210
@ TSCS_thread_local
C++11 thread_local.
Definition Specifiers.h:216
@ TSCS_unspecified
Definition Specifiers.h:211
@ TSCS__Thread_local
C11 _Thread_local.
Definition Specifiers.h:219
@ TSCS___thread
GNU __thread.
Definition Specifiers.h:213
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
MutableArrayRef< Expr * > MultiExprArg
Definition Ownership.h:272
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition Linkage.h:23
@ InternalLinkage
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition Linkage.h:31
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition ASTLambda.h:27
@ Parameter
The parameter type of a method or function.
@ Result
The result type of a method or function.
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
Definition Specifiers.h:276
TagTypeKind
The kind of a tag type.
Definition Type.h:5300
@ TTK_Class
The "class" keyword.
Definition Type.h:5311
@ TTK_Enum
The "enum" keyword.
Definition Type.h:5314
@ TTK_Struct
The "struct" keyword.
Definition Type.h:5302
@ TTK_Union
The "union" keyword.
Definition Type.h:5308
@ TTK_Interface
The "__interface" keyword.
Definition Type.h:5305
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...
Definition CharInfo.h:87
bool isDiscardableGVALinkage(GVALinkage L)
Definition Linkage.h:81
ExprResult ExprError()
Definition Ownership.h:278
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ TU_Complete
The translation unit is a complete translation unit.
@ TNK_Type_template
The name refers to a template whose specialization produces a type.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
Definition Lambda.h:22
@ LCD_ByRef
Definition Lambda.h:25
@ LCD_None
Definition Lambda.h:23
@ LCD_ByCopy
Definition Lambda.h:24
int hasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope, const IdentifierInfo *Attr, const TargetInfo &Target, const LangOptions &LangOpts)
Return the version number associated with the attribute if we recognize and implement the attribute s...
Definition Attributes.cpp:8
@ VK_RValue
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition Specifiers.h:110
MultiVersionKind
Definition Decl.h:1794
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition DeclBase.h:1198
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
Definition Specifiers.h:173
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
Definition Specifiers.h:169
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition Specifiers.h:253
@ CC_X86StdCall
Definition Specifiers.h:255
U cast(CodeGen::Address addr)
Definition Address.h:108
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
Definition Ownership.h:243
@ ETK_Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition Type.h:5337
@ ETK_None
No keyword precedes the qualified type name.
Definition Type.h:5340
@ EST_None
no exception specification
@ EST_BasicNoexcept
noexcept
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition Visibility.h:33
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition Specifiers.h:98
@ AS_public
Definition Specifiers.h:99
@ AS_protected
Definition Specifiers.h:100
@ AS_none
Definition Specifiers.h:102
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
Definition ASTLambda.h:38
#define NULL
#define bool
Definition stdbool.h:15
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
SourceRange getCXXOperatorNameRange() const
getCXXOperatorNameRange - Gets the range of the operator name (without the operator keyword).
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
const DeclarationNameLoc & getInfo() const
struct CXXOpName CXXOperatorName
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition DeclSpec.h:1340
ArrayRef< NamedDecl * > getDeclsInPrototype() const
Get the non-parameter decls defined within this function prototype.
Definition DeclSpec.h:1491
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition DeclSpec.h:1315
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
Definition DeclSpec.h:1280
One instance of this struct is used for each type in a declarator that is parsed.
Definition DeclSpec.h:1173
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Definition DeclSpec.h:1573
enum clang::DeclaratorChunk::@205 Kind
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
Definition DeclSpec.cpp:160
MemberPointerTypeInfo Mem
Definition DeclSpec.h:1554
FunctionTypeInfo Fun
Definition DeclSpec.h:1552
static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, bool lvalue)
Return a DeclaratorChunk for a reference.
Definition DeclSpec.h:1597
EvalResult is a struct with detailed info about an evaluated expression.
Definition Expr.h:608
Extra information about a function prototype.
Definition Type.h:3960
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI)
Definition Type.h:3975
Contains information gathered from parsing the contents of TargetAttr.
Definition Attr.h:352
std::vector< std::string > Features
Definition Attr.h:353
StringRef Architecture
Definition Attr.h:354
Describes how types, statements, expressions, and declarations should be printed.
SourceLocation PragmaLocation
Definition Sema.h:457
NamedDecl * Previous
Definition Sema.h:2303
Information about a template-id annotation token.
unsigned NumArgs
NumArgs - The number of template arguments.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.